# -*- coding: utf-8 -*-

 ###############################################
 ##                                             ##
 ##   Empresa Básica                             ##
 ##                                              ##
 ##                                              ##
 ##                                              ##
 ##   por Críptidos Digitales                    ##
 ##   GPL (c)2008                                ##
  ##                                             ##
    ###############################################

# print (0), "  compras.igu           begin"

import sys
from decimal import Decimal as dec
from PyQt4 import QtCore, QtGui

from cdWidgets import cdFrame
import cdWidgets

import frame_ui

import administradorCompras_ui as administrador_ui

import capturaCompra_ui as captura_ui
import detallesCompra_ui as detalles_ui
import pagos_ui


import manejador
import utilities

# print (0), "  compras.igu             definitions"


class Forma(cdFrame.CDFrame):

    @property
    def app(self):
        return self.__app

    @property
    def eventRouter(self):
        return self.__eventRouter

    @property
    def owner(self):
        return self.__owner

    def __init__(self, *args, **kwds):
        m = "compras.igu.Forma.__init__()"
        # print (1), m

        if kwds.has_key('app'):
            self.__app = kwds.pop('app')
        else:
            self.__app = None

        if 'eventRouter' in kwds.keys():
            self.__eventRouter = kwds.pop('eventRouter')
        else:
            self.__eventRouter = None

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        cdFrame.CDFrame.__init__(self, *args)

        self.ui = frame_ui.Ui_Form()
        self.ui.setupUi(self)

        self.ui.frame1.close()
        self.ui.frame2.close()
        self.ui.frame3.close()

        ## Detalles
        self.detalles = Detalles(self, owner=self)
        self.detalles.hide()
        self.detalles.status = 'normal'

        ## Captura
        self.captura = Captura(self, owner=self)
        # self.connect(self.captura, QtCore.SIGNAL("changed()"), self.changed)
        self.connect(self.captura, QtCore.SIGNAL("capturaClosed()"), self.capturaClosed)
        self.captura.hide()

        ## Administrador
        self.administrador = Administrador(self, owner=self, app=self.app)

        self.ui.outerSplitter = Splitter(QtCore.Qt.Vertical, self)
        ## InnerSplitter
        self.ui.innerSplitter = Splitter(QtCore.Qt.Horizontal, self.ui.outerSplitter)
        self.ui.innerSplitter.insertWidget(0, self.administrador)
        self.ui.innerSplitter.insertWidget(1, self.detalles)
        self.connect(self.ui.innerSplitter.handle(1), QtCore.SIGNAL("handlePressed"), self.innerHandlePressed)
        self.ui.innerSplitter.setSizes([1, 1])

        ## OuterSplitter
        self.ui.outerSplitter.insertWidget(0, self.ui.innerSplitter)
        self.ui.outerSplitter.insertWidget(1, self.captura)
        self.connect(self.ui.outerSplitter.handle(1), QtCore.SIGNAL('handlePressed'), self.outerHandlePressed)
        self.ui.outerSplitter.setSizes([1, 1])
        self.ui.verticalLayout.addWidget(self.ui.outerSplitter)

    def capturaClosed(self):                # print "compras.igu.Forma.capturaClosed()"
        self.setInnerStatus("visible")
        self.administrador.actualizaBotones()

    def innerHandlePressed(self):
        self.toggleDetalles()

    def outerHandlePressed(self):           # print "compras.igu.Forma.outerHandlePressed()"
        if self.ui.outerSplitter.sizes()[0] == 0:
            self.setInnerStatus('visible')
        else:
            self.setInnerStatus('hidden')


    def setInnerStatus(self, value):        # print "compras.igu.Forma.setInnerStatus(%s)" % value
        if value == 'visible':
            self.administrador.show()
            if self.detalles.status == 'hidden':
                self.detalles.show()
                self.detalles.status = "normal"

        elif value == 'hidden':
            self.administrador.hide()
            if self.detalles.isVisible():
                self.detalles.status = "hidden"
                self.detalles.hide()

        elif value == 'disabled':
            print 'disables'

    def toggleDetalles(self, *args):        # print "compras.igu.Forma.toggleDetalles()"
        if self.detalles.isVisible():
            self.detalles.hide()
        else:
            self.detalles.show()
            if self.administrador.ui.tablaConsulta.currentRow() != -1:
                id = self.administrador.ui.tablaConsulta.item(self.administrador.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
                self.detalles.mostrar(id)
                #~ data = manejador.dameDocumento(id=id)

                #~ pago = manejador.damePagos(documento_id=id)
                #~ if pago:
                    #~ data.pago = pago[0]
                #~ else:
                    #~ data.pago = {}

                #~ self.detalles.setData(data)



class Administrador(cdFrame.CDFrame):

    @property
    def app(self):
        return self.__app

    @property
    def eventRouter(self):
        return self.parent().eventRouter

    @property
    def owner(self):
        return self.__owner

    def __init__(self, *args, **kwds):
        m = "compras.igu.Administrador.__init__()"

        if kwds.has_key('app'):
            self.__app = kwds.pop('app')
        else:
            self.__app = None

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        cdFrame.CDFrame.__init__(self, *args)

        self.ui = administrador_ui.Ui_Form()
        self.ui.setupUi(self)

        font = QtGui.QFont()
        font.setBold(True)
        font.setPointSize(9*self.app.fontZoom)

        font2 = QtGui.QFont()
        font2.setPointSize(8*self.app.fontZoom)

        ## FILTROS
        self.ui.laProveedor.setStyleSheet("enabled{background-color:#0000FF; color:#FFFFFF;}")
        self.ui.laStatus.setStyleSheet("enabled{background-color:#0000FF; color:#FFFFFF;}")

        self.cargaProveedores()
        self.connect(self.ui.cbProveedor, QtCore.SIGNAL("currentIndexChanged(int)"), self.currentProveedorChanged)

        self.connect(self.ui.ch1, QtCore.SIGNAL('stateChanged(int)'), self.actualizaConsulta)
        self.connect(self.ui.ch2, QtCore.SIGNAL('stateChanged(int)'), self.actualizaConsulta)

        ## TABLA DE CONSULTA
        # self.ui.tablaConsulta.setStyleSheet("background-color:#FFFFFF")
        self.ui.tablaConsulta.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
        self.ui.tablaConsulta.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
        self.ui.tablaConsulta.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self.ui.tablaConsulta.setColumnCount(8)
        self.ui.tablaConsulta.setHorizontalHeaderLabels([u"Id", u"Documento", u"Folio", u"Fecha",  u"Proveedor", u"Monto", u"Saldo", u"Status"])
        self.ui.tablaConsulta.hideColumn(0)
        self.ui.tablaConsulta.horizontalHeader().setResizeMode(4, QtGui.QHeaderView.Stretch)
        # self.ui.tablaConsulta.setToolTip(u"ALT+D muestra detalles de la Compra seleccionada")

        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemDoubleClicked(QTableWidgetItem *)"), self.owner.toggleDetalles)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemSelectionChanged()"), self.selectionChanged)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("resized(QEvent)"), self.resizedTablaConsulta)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("customContextMenuRequested(QPoint)"), self.mostrarMenuConsulta)

        ## Agregar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Plus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aAgregar = QtGui.QAction(icon, u"&Agregar", self)
        self.aAgregar.setCheckable(True)
        self.aAgregar.setIconText(u"&Agregar")
        self.connect(self.aAgregar, QtCore.SIGNAL("triggered()"), self.agrega)

        self.ui.toAgregar.setDefaultAction(self.aAgregar)
        self.ui.toAgregar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toAgregar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Modificar
        icon1 = QtGui.QIcon()
        icon1.addPixmap(QtGui.QPixmap("imagenes/Redo.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aModificar = QtGui.QAction(icon1, u"&Modificar", self)
        self.aModificar.setCheckable(True)
        self.aModificar.setIconText(u"&Modificar")
        self.connect(self.aModificar, QtCore.SIGNAL("triggered()"), self.modifica)

        self.ui.toModificar.setDefaultAction(self.aModificar)
        self.ui.toModificar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toModificar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Eliminar
        icon2 = QtGui.QIcon()
        icon2.addPixmap(QtGui.QPixmap("imagenes/Minus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aEliminar = QtGui.QAction(icon2, u"&Eliminar", self)
        self.aEliminar.setCheckable(True)
        self.aEliminar.setIconText(u"&Eliminar")
        self.connect(self.aEliminar, QtCore.SIGNAL("triggered()"), self.elimina)

        self.ui.toEliminar.setDefaultAction(self.aEliminar)
        self.ui.toEliminar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toEliminar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Cerrar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Cash.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aCerrar = QtGui.QAction(icon, u"Pa&gar", self)
        self.aCerrar.setCheckable(True)
        self.aCerrar.setIconText(u"Pa&gar")
        self.connect(self.aCerrar, QtCore.SIGNAL("triggered()"), self.cierra)

        self.ui.toCerrar.setDefaultAction(self.aCerrar)
        self.ui.toCerrar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toCerrar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Imprimir
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Print.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aImprimir = QtGui.QAction(icon, u"Imprimir", self)
        self.aImprimir.setIconText(u"&Imprimir")
        self.connect(self.aImprimir, QtCore.SIGNAL("triggered()"), self.imprime)

        self.ui.toImprimir.setDefaultAction(self.aImprimir)
        self.ui.toImprimir.setIconSize(QtCore.QSize(44, 40))
        self.ui.toImprimir.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
        self.ui.toImprimir.setToolTip(u"Se imprime sólo los renglones mostrados en la lista")

        ## Menu
        self.menuTablaConsulta = QtGui.QMenu(self)
        self.menuTablaConsulta.addAction(self.aAgregar)
        self.menuTablaConsulta.addAction(self.aModificar)
        self.menuTablaConsulta.addAction(self.aEliminar)

        self.connect(self.eventRouter, QtCore.SIGNAL('comprasChangedBroadcast()'), self.actualizaConsulta)
        # Sólo para el caso de que no existan productos
        self.connect(self.eventRouter, QtCore.SIGNAL('productosChangedBroadcast()'), self.actualizaBotones)
        self.connect(self.eventRouter, QtCore.SIGNAL('proveedoresChangedBroadcast()'), self.cargaProveedores)

        self.actualizaConsulta()

        self.setFocusPolicy(QtCore.Qt.StrongFocus)

        self.connect(self, QtCore.SIGNAL('showed()'), self.showed)

        registros = manejador.dameProcesos()


    def actualizaBotones(self):     # print "compras.igu.Administrador.actualizaBotones()"
        if not self.owner.captura.isVisible():
            self.aAgregar.setChecked(False)
            self.aModificar.setChecked(False)
        self.aEliminar.setChecked(False)
        self.aCerrar.setChecked(False)
        self.aImprimir.setChecked(False)

        mensajesFiltros = u""
        mensajesAlta = u""
        mensajesModifica = u""
        mensajesElimina = u""
        mensajesPaga = u""
        mensajesImprime = u""

        if manejador.totalDeProductos() == 0:
            mensajesAlta += u"No hay productos registrados\n"
        if manejador.totalDeProveedores() == 0:
            mensajesAlta += u"No hay proveedores registrados\n"
            mensajesFiltros += u"No hay proveedores registrados\n"

        if manejador.totalDeCompras() == 0:
            mensajesFiltros += u"No hay compras registradas\n"
            mensajesModifica += u"No hay compras registradas\n"
            mensajesElimina += u"No hay compras registradas\n"
            mensajesPaga += u"No hay compras registradas\n"
            mensajesImprime += u"No hay compras para imprimir\n"
        elif self.ui.tablaConsulta.rowCount() == 0:
            mensajesModifica += u"No hay compras desplegadas\n"
            mensajesElimina += u"No hay compras desplegadas\n"
            mensajesPaga += u"No hay compras desplegadas\n"
            mensajesImprime += u"No hay compras desplegadas\n"
        elif self.ui.tablaConsulta.rowCount() > 0:
            if self.ui.tablaConsulta.currentRow() == -1:
                mensajesModifica += u"Selecciona la Compra que quieres Modificar"
                mensajesElimina += u"Selecciona la Compra que quieres Eliminar"
                mensajesPaga += u"Selecciona la Compra que quieres Pagar"
            else:
                if self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 4).text()==u'cerrado':
                    mensajesPaga += u"Esta compra ya está pagada"

        if mensajesFiltros:
            self.ui.frFiltros.setToolTip(mensajesFiltros.rstrip("\n"))
            self.ui.frFiltros.setEnabled(False)
            self.ui.frProveedor.setToolTip(u"")
        else:
            self.ui.frFiltros.setEnabled(True)
            self.ui.frFiltros.setToolTip(u"")

        if mensajesAlta:
            self.aAgregar.setEnabled(False)
            self.aAgregar.setToolTip(mensajesAlta.rstrip("\n"))
        else:
            self.aAgregar.setEnabled(True)
            self.aAgregar.setToolTip(u"Presiona para registrar una Compra nueva")

        # self.aModificar.setEnabled(False)
        # self.aModificar.setToolTip(u"La modificación de compras no está implementada")

        if mensajesModifica:
            self.aModificar.setEnabled(False)
            self.aModificar.setToolTip(mensajesModifica.rstrip("\n"))
        else:
            self.aModificar.setEnabled(True)
            self.aModificar.setToolTip(u"Presiona para modificar los datos de la Compra seleccionada")

        self.aEliminar.setEnabled(False)
        self.aEliminar.setToolTip(u"El borrado de compras no está autorizado")

        if mensajesPaga:
            self.aCerrar.setEnabled(False)
            self.aCerrar.setToolTip(mensajesPaga.rstrip("\n"))
        else:
            self.aCerrar.setEnabled(True)
            self.aCerrar.setToolTip(u"Presiona para pagar la Compra seleccionada")

        if mensajesImprime:
            self.aImprimir.setEnabled(False)
            self.aImprimir.setToolTip(mensajesImprime.rstrip("\n"))
        else:
            self.aImprimir.setEnabled(True)
            self.aImprimir.setToolTip(u"Presiona para Imprimir las compras mostradas")


    def actualizaConsulta(self, *args):
        m = "compras.igu.Administrador.actualizaConsulta()"

        filtros = {}

        if self.ui.cbProveedor.currentIndex() > 0:
            filtros['rol_id'] = self.ui.cbProveedor.itemData(self.ui.cbProveedor.currentIndex()).toInt()[0]

        old = self.currentId()

        all = 0
        status = []
        if self.ui.ch1.isChecked():
            status.append(u'abierto')
            all += 1
        if self.ui.ch2.isChecked():
            status.append(u'cerrado')
            all += 1

        if not all == 2:
            filtros['status'] = status

        procesos = manejador.dameProcesos(**filtros)

        self.ui.tablaConsulta.setSortingEnabled(False)

        self.ui.tablaConsulta.setRowCount(0)

        color = QtGui.QColor(1,1,1)
        saldo = dec('0.00')
        documentosProcesados = []

        for indexProceso, proceso in enumerate(procesos):
            if indexProceso%2:
                color.setNamedColor('#E0E0FF')
            else:
                color.setNamedColor('#FFFFE0')

            subProcesos = []

            for indexOperacion, operacion in enumerate(proceso.operaciones):

                if operacion.tipo == u'entrada':
                    if operacion.documentos:
                        documento = operacion.documentos[0]
                        if not documento.id in documentosProcesados:
                            # proceso = manejador.procesoI(documento_id=documento.id)
                            subProcesos.append([documento.id, documento.tipo.nombre, documento.folio, documento.fecha, "%s %s" % (documento.rol.entidad.nombre, documento.rol.entidad.nombre2), documento.total, proceso.status.capitalize(), proceso.id])
                            documentosProcesados.append(documento.id)

            for indexSubproceso in range(len(subProcesos)-1):
                for indexSubproceso2 in range(len(subProcesos)-1-indexSubproceso):
                    if subProcesos[indexSubproceso2][3] > subProcesos[indexSubproceso2+1][3]:
                        temp = subProcesos[indexSubproceso2]
                        subProcesos[indexSubproceso2] = subProcesos[indexSubproceso2+1]
                        subProcesos[indexSubproceso2+1] = temp

            for indexSubproceso, subProceso in enumerate(subProcesos):

                self.ui.tablaConsulta.insertRow(0)

                if subProceso[1] in [u'factura', u'remisión']:
                    saldo -= abs(subProceso[5])
                elif not subProceso[1] in [u'pedido']:
                    saldo += abs(subProceso[5])

                item = QtGui.QTableWidgetItem("")
                item.setData(1000, QtCore.QVariant(subProceso[0]))
                self.ui.tablaConsulta.setItem(0, 0, item)

                item = QtGui.QTableWidgetItem(subProceso[1].capitalize())
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                item.setBackgroundColor(color)
                item.setData(1000, QtCore.QVariant(subProceso[0]))  # Documento.id
                item.setData(1001, QtCore.QVariant(subProceso[7]))  # Proceso.id
                self.ui.tablaConsulta.setItem(0, 1, item)

                item = QtGui.QTableWidgetItem("%s" % subProceso[2])
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                item.setTextAlignment(QtCore.Qt.AlignCenter)
                item.setBackgroundColor(color)
                self.ui.tablaConsulta.setItem(0, 2, item)

                item = QtGui.QTableWidgetItem(subProceso[3].strftime("%d %b %Y"))
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                item.setTextAlignment(QtCore.Qt.AlignCenter)
                item.setBackgroundColor(color)
                self.ui.tablaConsulta.setItem(0, 3, item)

                item = QtGui.QTableWidgetItem(subProceso[4])
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                item.setBackgroundColor(color)
                self.ui.tablaConsulta.setItem(0, 4, item)

                item = QtGui.QTableWidgetItem("%.2f" % subProceso[5])
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                item.setTextAlignment(QtCore.Qt.AlignCenter)
                item.setBackgroundColor(color)
                self.ui.tablaConsulta.setItem(0, 5, item)

                item = QtGui.QTableWidgetItem("%.2f" % saldo)
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                item.setTextAlignment(QtCore.Qt.AlignCenter)
                item.setBackgroundColor(color)
                self.ui.tablaConsulta.setItem(0, 6, item)

                item = QtGui.QTableWidgetItem(subProceso[6])
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                item.setTextAlignment(QtCore.Qt.AlignCenter)
                item.setBackgroundColor(color)
                self.ui.tablaConsulta.setItem(0, 7, item)

        self.ui.tablaConsulta.setSortingEnabled(True)

        self.setCurrentId(old)

        self.actualizaBotones()

        #! Sustituir setRowCount por insertRow


    def agrega(self):
        self.owner.captura.agrega()


    def cargaProveedores(self):
        m = "compras.igu.Administrador.cargaProveedores()"

        old = self.ui.cbProveedor.itemData(self.ui.cbProveedor.currentIndex()).toInt()[0]
        self.ui.cbProveedor.clear()
        proveedores = manejador.dameProveedores()

        if proveedores:
            self.ui.cbProveedor.addItem(u"", QtCore.QVariant(self.owner.app.holder.id))
            for rol in proveedores:
                self.ui.cbProveedor.addItem("%s %s" % (rol.entidad.nombre, rol.entidad.nombre2), QtCore.QVariant(rol.id))

            if self.ui.frProveedor.isEnabled():
                self.ui.frProveedor.setToolTip(u"Seleccione uno para filtrar la lista")
        else:
            self.ui.cbProveedor.addItem("No hay proveedores", QtCore.QVariant(-1))
            self.ui.frProveedor.setToolTip(u"No hay proveedores capturados")
            # self.ui.cbProveedor.addItem("Debe dar de alta al proveedor", QtCore.QVariant(-1))
        if old > 0:
            self.ui.cbProveedor.setCurrentIndex(self.ui.cbProveedor.findData(old))
        else:
            self.ui.cbProveedor.setCurrentIndex(0)


    # def currentChanged(self, new, old):
        # print "compras.igu.Administrador.currentChanged()"
        # if new and not old:
            # self.toggleDetalles()


    def cierra(self):
        if self.ui.tablaConsulta.currentRow() == -1:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Pagar compra", u"Selecciona la COMPRA que quieres PAGAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            self.owner.captura.paga(id)


    def currentId(self):
        if self.ui.tablaConsulta.currentRow() != -1:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
        else:
            id = None
        return id


    def currentProveedorChanged(self, index):
        self.actualizaConsulta()


    def elimina(self):
        if self.ui.tablaConsulta.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Eliminar compra", u"Selecciona la COMPRA que quieres ELIMINAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            dato = manejador.dameDocumento(id=id)
            result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Eliminar compra", u"¿Realmente quieres ELIMINAR la COMPRA %s %s?" % (dato.folio, dato.fecha), QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
            if result == QtGui.QMessageBox.Yes:
                manejador.elimina(id=id)
                self.eventRouter.emit(QtCore.SIGNAL('comprasChangedBroadcast()'))
            self.actualizaBotones()


    def findData(self, data):
        index = -1
        for row in range(self.ui.tablaConsulta.rowCount()):
            if self.ui.tablaConsulta.item(row, 0).data(1000)==QtCore.QVariant(data):
                index = row
        return index



    def imprime(self):              # print "compras.igu.Administrador.imprime()"
        dialogoImpresora = QtGui.QPrintDialog(self.impresor)
        if dialogoImpresora.exec_() == QtGui.QDialog.Accepted:
            painter = QtGui.QPainter(self.impresor)
            margenHorizontal, margenVertical = [10, 10]

            font1 = QtGui.QFont("courier", 10)
            font1.setBold(True)
            font2 = QtGui.QFont("courier", 9)
            font3 = QtGui.QFont("Courier", 12)
            font3.setBold(True)

            margenX, margenY = [25, 75]
            pageWidth, pageHeight = (self.impresor.paperRect().width(), self.impresor.paperRect().height())
            pageNo = 1

            ## HEADER
            header = []
            x, y = [25, 0]
            header.append([pageWidth/2-100, margenY+y, u"Catálogo de Empleados", font3])
            x, y = [400, 25]
            header.append([pageWidth-200, margenY+y, u"Fecha: %s" % QtCore.QDate().currentDate().toString('dd MMM yyyy'), font1])

            # x, y = [0, 100]
            # header.append([margenX+x, margenY+y, u"    Nombre                                     RFC            Teléfonos", font1])

            tabla = self.ui.tablaConsulta

            x, y = [0, 75]
            contenido = []
            footer = []
            offset = 0
            for row in range(tabla.rowCount()):
                if offset == 0:
                    contenido.extend(header)
                posX, posY = (margenX + x, margenY + y + offset)
                contenido.append([posX    , posY, str(row+1), font2])
                contenido.append([posX+40 , posY, tabla.item(row, 0).text(), font2])    # Nombre
                contenido.append([posX+90 , posY+18, tabla.item(row, 4).text(), font2]) # Domicilio
                contenido.append([posX+90 , posY+36, tabla.item(row, 3).text(), font2]) # Lugar
                contenido.append([posX+90 , posY+54, u"RFC: %s   Teléfonos: %s" % (tabla.item(row, 1).text(), tabla.item(row, 2).text()), font2]) # RFC, Teléfono
                # if tabla.item(row, 5):
                    # contenido.append([posX+690, posY, tabla.item(row, 5).text(), font2])# Importe
                offset += 80
                if posY+190 >= pageHeight:
                    contenido.append([pageWidth/2-50, pageHeight-50, "Hoja %s" % pageNo, font2])
                    for item in contenido:
                        painter.setFont(item[3])
                        painter.drawText(QtCore.QPoint(margenHorizontal + item[0], margenVertical + item[1]), item[2])
                    offset = 0
                    contenido = []
                    footer = []
                    pageNo += 1
                    self.impresor.newPage()

            contenido.append([pageWidth/2-50, pageHeight-50, "Hoja %s" % pageNo, font2])
            for item in contenido:
                painter.setFont(item[3])
                painter.drawText(QtCore.QPoint(margenHorizontal + item[0], margenVertical + item[1]), item[2])


    def modifica(self):             # print "compras.igu.Administrador.modifica()"
        if self.ui.tablaConsulta.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Modificar compra", u"Selecciona la COMPRA que quieres MODIFICAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            self.setCursor(QtCore.Qt.WaitCursor)
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 1).data(1001).toInt()[0]
            self.owner.captura.modifica(id)
            self.setCursor(QtCore.Qt.ArrowCursor)


    def mostrarMenuConsulta(self, pos):
        pos = self.ui.tablaConsulta.mapToGlobal(pos)
        self.menuTablaConsulta.popup(pos)


    # def paga(self, id):             # print "compras.igu.Administrador.paga()"
        # id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
        # self.owner.captura.paga(id)


    def resizedTablaConsulta(self, event):
        headerWidth = self.ui.tablaConsulta.width()-self.ui.tablaConsulta.verticalHeader().width()-self.ui.tablaConsulta.verticalScrollBar().width()-1
        self.ui.tablaConsulta.horizontalHeader().setMinimumWidth(headerWidth)

        porcentajes = [0, 10, 10, 15, 12, 12]
        overflow = 0

        for index in range(self.ui.tablaConsulta.horizontalHeader().count()-1):
            if not self.ui.tablaConsulta.isColumnHidden(index):
                self.ui.tablaConsulta.resizeColumnToContents(index)

                porContenido = self.ui.tablaConsulta.columnWidth(index)
                calculado = headerWidth * porcentajes[index] / 100

                if porContenido < calculado:
                    if overflow:
                        offset = calculado - porContenido
                        if offset > overflow:
                            calculado = calculado - overflow
                            overflow = 0
                        else:
                            overflow -= offset
                            calculado = porContenido
                    self.ui.tablaConsulta.setColumnWidth(index, calculado)
                else:
                    overflow += porContenido - calculado


    def selectionChanged(self):
        if self.ui.tablaConsulta.currentRow() != -1:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            if self.owner.detalles.isVisible():
                self.owner.detalles.mostrar(id)
            if self.owner.captura.isVisible():
                if self.owner.captura.modo == 'modificar':
                    if self.owner.captura.id != id:
                        if self.owner.captura.estaModificado():
                            result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Modificación de Compra", u"La captura de Compra tiene cambios\n\n¿Quieres Guardar los cambios para %s %s %s?" % (self.owner.captura.old.tipo, self.owner.captura.old.folio, self.owner.captura.old.fecha), QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)

                            if result == QtGui.QMessageBox.Yes:
                                self.owner.captura.guarda()
                        self.owner.captura.modifica(id)
        self.actualizaBotones()


    def setCurrentId(self, id):
        self.ui.tablaConsulta.setCurrentItem(self.ui.tablaConsulta.item(self.findData(id), 0))


    def showed(self):
        self.owner.owner.informacion = u""



class Captura(cdFrame.CDFrame):

    @property
    def eventRouter(self):
        return self.owner.eventRouter

    def __init__(self, *args, **kwds):
        m = "compras.igu.Captura.__init__()"
        # print (1), m

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        self.__modo = None

        cdFrame.CDFrame.__init__(self, *args)

        self.ui = captura_ui.Ui_Form()
        self.ui.setupUi(self)

        # self.ui.frame.setStyleSheet("QFrame:enabled{background-color:#E0E0E0}")
        self.connect(self.ui.frame, QtCore.SIGNAL('returnPressed()'), self.returnPressed)

        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
        self.setSizePolicy(sizePolicy)
        self.setBaseSize(QtCore.QSize(50, 0))

        ## Frame Header
        self.ui.frHeader.setStyleSheet("enabled{background-color:qradialgradient(cx:.5, cy:.5, radius:1,fx:.5, fy:.25, stop: 0 #FFFFFF, stop:1 #B0B0B0); border-top-left-radius:3px; border-top-right-radius:3px;}")

        ## Folio
        self.ui.edFolio.setStyleSheet("color:#202020;")
        self.connect(self.ui.edFolio, QtCore.SIGNAL('textEdited(QString)'), self.folioEditado)

        ## Fecha
        self.ui.fecha.setDisplayFormat("dd MMM yyyy")
        self.ui.fecha.setMaximumDate(QtCore.QDate(QtCore.QDate().currentDate().year(), 12, QtCore.QDate().currentDate().day()))
        self.connect(self.ui.fecha, QtCore.SIGNAL('dateChanged(QDate)'), self.actualizaStatus)

        ## Pedido
        self.ui.cbPedido.setEditable(True)
        self.connect(self.ui.cbPedido, QtCore.SIGNAL("activated(int)"), self.pedidoSeleccionado)
        self.cargaPedidos()

        ## Condiciones
        self.ui.laCondiciones.setStyleSheet("color:#FFFFFF; background-color:#70A0F0;")

        ## Pago
        self.ui.frPago.hide()

        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Cash.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boPagar.setIcon(icon)
        self.ui.boPagar.setIconSize(QtCore.QSize(32,32))

        self.connect(self.ui.boPagar, QtCore.SIGNAL('clicked()'), self.paga)

        self.pago = Pago(self)

        self.ui.frCuentaPago.hide()
        self.ui.frNumeroPago.hide()
        self.ui.frCambioPago.hide()

        ## Tabla partidas (tipos de documento lo requiere)
        self.ui.tablaPartidas = TablaPartidas(self.ui.frCaptura, owner=self)
        self.ui.tablaPartidas.setTabKeyNavigation(False)
        self.ui.tablaPartidas.setStyleSheet("background-color:#FFFFFF;")
        self.ui.tablaPartidas.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
        labels = [u"Código", u"Nombre", u"Línea", u"Cantidad", u"Precio", u"Importe"]
        self.ui.tablaPartidas.setColumnCount(len(labels))
        self.ui.tablaPartidas.setHorizontalHeaderLabels(labels)
        self.ui.tablaPartidas.horizontalHeader().setResizeMode(1, QtGui.QHeaderView.Stretch)
        self.ui.layoutCaptura.insertWidget(3, self.ui.tablaPartidas)

        self.connect(self.ui.tablaPartidas, QtCore.SIGNAL("totalChanged(dec)"), self.totalChanged)
        self.connect(self.ui.tablaPartidas, QtCore.SIGNAL('editingFinished()'), self.partidaCapturada)

        self.setStatus(u'init')

        self.cargaCondiciones()

        ## Carga tipos de Documento
        self.ui.cbTipoDocumento.clear()
        tipos = manejador.tiposDocumento()
        for tipo in tipos:
            self.ui.cbTipoDocumento.addItem(tipo.nombre.capitalize(), QtCore.QVariant(tipo.id))
        self.connect(self.ui.cbTipoDocumento, QtCore.SIGNAL("currentIndexChanged(QString)"), self.setTipoDocumento)

        ## Proveedor
        self.cargaProveedores()

        self.ui.laProveedor.setStyleSheet("color:#FFFFFF; background-color:#70A0F0;")
        self.connect(self.ui.cbEntidad, QtCore.SIGNAL("currentIndexChanged(int)"), self.rolSelected)


        ## Origen de datos
        self.cargaOrigenes()
        self.connect(self.ui.cbOrigen, QtCore.SIGNAL('activated(int)'), self.origenChanged)

        ## Codigo de Producto
        completer = QtGui.QCompleter([], self.ui.edCodigoProducto)
        completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        model = Model(completer)
        completer.setModel(model)
        self.ui.edCodigoProducto.setCompleter(completer)

        self.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.codigoProductoSeleccionado)
        self.connect(self.ui.edCodigoProducto, QtCore.SIGNAL('returnPressed()'), self.codigoProductoCapturado)
        # self.connect(self.ui.edCodigoProducto, QtCore.SIGNAL('editingFinished()'), self.codigoProductoCapturado)
        self.connect(self.ui.edCodigoProducto, QtCore.SIGNAL('textEdited(QString)'), self.codigoProductoEditado)

        ## Nombre de Producto
        completer = QtGui.QCompleter([], self.ui.edNombreProducto)
        completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)

        model = Model(completer)
        completer.setModel(model)

        self.ui.edNombreProducto.setCompleter(completer)

        # self.ui.edNombreProducto.setStyleSheet('background-color:#F8F8FF')

        self.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.nombreProductoSeleccionado)
        self.connect(self.ui.edNombreProducto, QtCore.SIGNAL('returnPressed()'), self.nombreProductoCapturado)
        # self.connect(self.ui.edNombreProducto, QtCore.SIGNAL('editingFinished()'), self.nombreProductoCapturado)
        # self.connect(self.ui.edNombreProducto, QtCore.SIGNAL('returnPressed()'), self.nombreProductoSeleccionado)
        self.connect(self.ui.edNombreProducto, QtCore.SIGNAL('textEdited(QString)'), self.nombreProductoEditado)

        ## Lineas
        self.cargaLineas()

        ## Subtotal
        self.ui.edSubtotal.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edSubtotal.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edSubtotal.setRange(0, 99999)

        ## Descuento
        self.ui.edDescuento.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edDescuento.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edDescuento.setRange(0, 99999)
        self.connect(self.ui.edDescuento, QtCore.SIGNAL('editingFinished()'), self.descuentoChanged)

        ## Porcentaje de descuento
        self.ui.edDescuentoPorcentaje.setAlignment(QtCore.Qt.AlignCenter)
        self.ui.edDescuentoPorcentaje.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5)/2)
        self.ui.edDescuentoPorcentaje.setEmptyAllowed(True)
        self.ui.edDescuentoPorcentaje.setRange(0, 75)
        self.ui.edDescuentoPorcentaje.setDecimals(-1)
        self.connect(self.ui.edDescuentoPorcentaje, QtCore.SIGNAL('editingFinished()'), self.porcentajesChanged)

        ## Subtotal2
        self.ui.edSubtotal2.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edSubtotal2.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)

        ## Impuesto
        self.ui.edImpuesto.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edImpuesto.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edImpuesto.setRange(0, 99999)
        self.connect(self.ui.edImpuesto, QtCore.SIGNAL('editingFinished()'), self.impuestoChanged)

        ## Porcentaje de impuesto
        self.ui.edImpuestoPorcentaje.setAlignment(QtCore.Qt.AlignCenter)
        self.ui.edImpuestoPorcentaje.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5)/2)
        self.ui.edImpuestoPorcentaje.setRange(0, 99)
        self.connect(self.ui.edImpuestoPorcentaje, QtCore.SIGNAL('editingFinished()'), self.porcentajesChanged)

        ## Total
        self.ui.edTotal.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edTotal.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edTotal.setRange(0, 99999)
        self.connect(self.ui.edTotal, QtCore.SIGNAL('textEdited(QString)'), self.totalEdited)

        ## Ajuste
        self.ui.chAjustes.setChecked(False)
        self.connect(self.ui.chAjustes, QtCore.SIGNAL('stateChanged(int)'), self.toggleAjustes)
        self.connect(self.ui.cbTipoAjuste, QtCore.SIGNAL('activated(int)'), self.actualizaStatus)
        self.connect(self.ui.cbTipoDocumentoAjuste, QtCore.SIGNAL('activated(int)'), self.actualizaStatus)
        self.connect(self.ui.fechaAjuste, QtCore.SIGNAL('dateChanged(QDate)'), self.actualizaStatus)
        self.connect(self.ui.edFolio, QtCore.SIGNAL('textEdited(QString)'), self.actualizaStatus)
        self.connect(self.ui.edMontoAjuste, QtCore.SIGNAL('textEdited(QString)'), self.actualizaStatus)
        self.ui.frTipoAjuste.hide()
        self.cargaTiposDocumentoAjuste()
        self.ui.frAjustes0.hide()
        self.ui.frAjustes.hide()

        self.ui.frAjuste.hide()

        ## Guardar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Check.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boGuardar.setIcon(icon)
        self.ui.boGuardar.setIconSize(QtCore.QSize(32,32))
        self.ui.boGuardar.setDefault(True)
        self.ui.boGuardar.setEnabled(False)
        self.connect(self.ui.boGuardar, QtCore.SIGNAL("clicked()"), self.guarda)

        ## Cancelar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Cancel.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boCancelar.setIcon(icon)
        self.ui.boCancelar.setIconSize(QtCore.QSize(32,32))
        self.connect(self.ui.boCancelar, QtCore.SIGNAL("clicked()"), self.cancela)

        # self.connect(self.eventRouter, QtCore.SIGNAL('cuentasChangedBroadcast()'), self.cargaCuentas)
        self.connect(self.eventRouter, QtCore.SIGNAL("pedidosChangedBroadcast()"), self.cargaPedidos)
        self.connect(self.eventRouter, QtCore.SIGNAL("proveedoresChangedBroadcast()"), self.cargaProveedores)

        self.mensajes2 = u""

        if self.modo == u'modificar':
            self.ui.edFolio.setEnabled(False)

        # self.setFocusPolicy(QtCore.Qt.StrongFocus)

        self.connect(self, QtCore.SIGNAL('showed()'), self.showed)

        self.setTabOrder(self.ui.cbPedido, self.ui.cbTipoDocumento)
        self.setTabOrder(self.ui.cbTipoDocumento, self.ui.edFolio)
        self.setTabOrder(self.ui.edFolio, self.ui.fecha)
        self.setTabOrder(self.ui.fecha, self.ui.cbEntidad)
        self.setTabOrder(self.ui.cbEntidad, self.ui.cbCondiciones)
        self.setTabOrder(self.ui.cbCondiciones, self.ui.edCodigoProducto)
        self.setTabOrder(self.ui.edCodigoProducto, self.ui.edNombreProducto)
        self.setTabOrder(self.ui.edNombreProducto, self.ui.cbLinea)
        self.setTabOrder(self.ui.cbLinea, self.ui.tablaPartidas)
        self.setTabOrder(self.ui.tablaPartidas, self.ui.edSubtotal)
        self.setTabOrder(self.ui.edSubtotal, self.ui.edDescuentoPorcentaje)
        self.setTabOrder(self.ui.edDescuentoPorcentaje, self.ui.edDescuento)
        self.setTabOrder(self.ui.edDescuento, self.ui.edSubtotal2)
        self.setTabOrder(self.ui.edSubtotal2, self.ui.edImpuestoPorcentaje)
        self.setTabOrder(self.ui.edImpuestoPorcentaje, self.ui.edImpuesto)
        self.setTabOrder(self.ui.edImpuesto, self.ui.edTotal)
        self.setTabOrder(self.ui.edTotal, self.ui.chAjustes)
        # self.setTabOrder(self.ui.chPago, )
        # self.setTabOrder(self.ui.cbTipoPago, self.ui.cbCuenta)
        # self.setTabOrder(self.ui.cbCuenta, self.ui.edNumeroCheque)
        # self.setTabOrder(self.ui.edNumeroCheque, self.ui.fechaPago)
        # self.setTabOrder(self.ui.fechaPago, self.ui.edMontoPago)
        # self.setTabOrder(self.ui.edMontoPago, self.ui.chAjustes)
        self.setTabOrder(self.ui.chAjustes, self.ui.boGuardar)
        self.setTabOrder(self.ui.boGuardar, self.ui.boCancelar)

        ## POSSET
        self.setTipoDocumento(manejador.tipoDocumentoDefault().nombre)
        # self.ui.edImpuestoPorcentaje.setValue(manejador.impuestoGeneral()) DONE AT setTipoDocumento

        self.__rangoPrecioActual = 0

        self.impuestoGeneralFactor = (manejador.impuestoGeneral() + dec('100')) / dec('100')

        self.setStatus(u'normal')

        print (2), m


    # def acepcionSeleccionada(self, acepcion):
        # if self.ui.edCodigoProducto.text() or self.ui.edNombreProducto.text():
            # row = self.ui.tablaPartidas.rowCount()
            # self.ui.tablaPartidas.insertRow(row)

            # self.ui.tablaPartidas.setDatosRenglon(index=row, acepcion=acepcion, cantidad=dec('0.0'), precio=acepcion.costo)

            # self.ui.edCodigoProducto.setText("")
            # self.ui.edNombreProducto.setText("")
            # self.ui.cbClasificacion.setCurrentIndex(0)

            # self.ui.tablaPartidas.setCurrentCell(row, CANTIDAD)
            # self.ui.tablaPartidas.editItem(self.ui.tablaPartidas.item(row, CANTIDAD))
            # self.actualizaStatus()

            # self.ui.frameNombre.setEnabled(True)
            # self.ui.frameNombre.setToolTip("")
            # self.ui.frameClasificacion.setEnabled(True)


    def actualizaStatus(self, args=None):
        m = "compras.igu.Captura.actualizaStatus()"
        # print (1), m

        if self.status == u'normal':
            if self.modo == 'modificar':
                if self.estaModificado():
                    if self.esValida():
                        self.ui.boGuardar.setEnabled(True)
                        self.ui.boGuardar.setToolTip(self.mensajes2)
                    else:
                        self.ui.boGuardar.setEnabled(False)
                        self.ui.boGuardar.setToolTip(self.mensajes)
                else:
                    self.ui.boGuardar.setEnabled(False)
                    self.ui.boGuardar.setToolTip(u"No hay cambios")
            elif self.modo == 'agregar':
                if self.esValida():
                    self.ui.boGuardar.setEnabled(True)
                else:
                    self.ui.boGuardar.setEnabled(False)
                self.ui.boGuardar.setToolTip(self.mensajes)


    def agrega(self):
        self.__modo = "agregar"

        self.ui.titulo.setText(QtGui.QApplication.translate("Empresa Básica", "Compra nueva", None, QtGui.QApplication.UnicodeUTF8))

        self.clear()

        self.ui.frameCaptura.setEnabled(True)
        self.ui.chAjustes.setChecked(False)

        self.ui.edFolio.setText(manejador.dameFolio())
        self.ui.fecha.setDate(QtCore.QDate().currentDate())

        self.ui.edCodigoProducto.setEnabled(True)
        self.ui.edNombreProducto.setEnabled(True)
        self.ui.cbLinea.setEnabled(True)

        self.ui.cbEntidad.setFocus()

        self.actualizaStatus()

        self.owner.owner.informacion = u"Para capturar partidas debe localizar el producto, por medio de su código o de su nombre"

        self.owner.setInnerStatus('hidden')

        self.show()


    def cancela(self):
        self.clear()
        self.hide()
        self.emit(QtCore.SIGNAL("capturaClosed()"))


    def cargaClasificaciones(self):
        clasificaciones = manejador.dameClasificaciones()
        self.ui.cbClasificacion.clear()
        self.ui.cbClasificacion.addItem("", QtCore.QVariant(-1))
        for clasificacion in clasificaciones:
            self.ui.cbClasificacion.addItem(clasificacion.nombre, QtCore.QVariant(clasificacion.id))


    def cargaCondiciones(self):
        condiciones = manejador.condicionesPago()
        for item in condiciones:
            self.ui.cbCondiciones.addItem(item.nombre)
        self.ui.cbCondiciones.setCurrentIndex(-1)


    def cargaCuentas(self):
        m = "compras.igu.Captura.cargaCuentas()"

        propio = manejador.rolI(tipo=u'propio')
        cuentas = [x for x in propio.atributos if x.nombre==u'cuenta']

        self.ui.cbCuenta.clear()

        if cuentas:
            for cuenta in cuentas:
                banco = manejador.rolI(id=int(cuenta.referencia))
                self.ui.cbCuenta.addItem("%s %s" % (cuenta.valor, banco.entidad.alias))
        else:
            self.ui.cbCuenta.setToolTip(u"No se han dado de alta las cuentas bancarias")


    def cargaLineas(self, **filtros):
        """ Filtra por Marca """
        lineas = manejador.lineas(**filtros)
        self.ui.cbLinea.clear()
        self.ui.cbLinea.addItem("", QtCore.QVariant(-1))
        for linea in lineas:
            self.ui.cbLinea.addItem(linea.nombre, QtCore.QVariant(linea.id))


    def cargaOrigenes(self):
        self.ui.cbOrigen.clear()
        origenes = manejador.dameProveedores()
        self.ui.cbOrigen.addItem(u"", QtCore.QVariant(self.owner.app.holder.id))
        for origen in origenes:
            self.ui.cbOrigen.addItem("%s %s" % (origen.entidad.nombre, origen.entidad.nombre2), QtCore.QVariant(origen.id))


    def cargaPedidos(self, rol_id=None):
        m = "compras.igu.Captura.cargaPedidos()"

        old = self.ui.cbPedido.itemData(self.ui.cbPedido.currentIndex())
        self.ui.cbPedido.clear()

        if rol_id:
            pedidos = manejador.damePedidos(sinCompra=u'', rol_id=rol_id)
        else:
            pedidos = manejador.damePedidos(sinCompra=u'')

        if pedidos:
            for item in pedidos:
                self.ui.cbPedido.addItem("%s" % item.folio, QtCore.QVariant(item.id))
        else:
            self.ui.cbPedido.addItem("No hay pedidos pendientes")
        # self.ui.cbPedido.setItemData(0, QtCore.QVariant(-1))
        self.ui.cbPedido.setItemData(-1, QtCore.QVariant(-1))

        if old > -1:
            self.ui.cbPedido.setCurrentIndex(self.ui.cbPedido.findData(old))


    def cargaProveedores(self):
        m = "compras.igu.Captura.cargaProveedores()"

        old = self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0]
        self.ui.cbEntidad.clear()
        proveedores = manejador.dameProveedores()
        self.ui.cbEntidad.addItem(u"", QtCore.QVariant(self.owner.app.holder.id))
        if proveedores:
            for rol in proveedores:
                self.ui.cbEntidad.addItem("%s %s" % (rol.entidad.nombre, rol.entidad.nombre2), QtCore.QVariant(rol.id))
        else:
            self.ui.cbEntidad.addItem("Debe dar de alta al proveedor", -1)

        if old > 0:
            self.ui.cbEntidad.setCurrentIndex(self.ui.cbEntidad.findData(old))


    def cargaTiposDocumentoAjuste(self):
        self.ui.cbTipoDocumentoAjuste.clear()
        tipos = manejador.dameTiposDocumentoAjuste()
        if tipos:
            for tipo in tipos:
                self.ui.cbTipoDocumentoAjuste.addItem("%s" % tipo.valor)


    def cargaTiposPago(self):
        self.ui.cbTipoPago.clear()
        tipos = manejador.formasPago()
        for tipo in tipos:
            self.ui.cbTipoPago.addItem("%s" % tipo.nombre.capitalize(), tipo.id)


    def clear(self):
        m = "compras.igu.Captura.clear()"
        # print (1), m

        statusBak = self.status
        self.setStatus(u"clearing")

        if self.modo == u'modificar':
            self.ui.cbPedido.hide()
            self.ui.edPedido.show()
        else:
            self.ui.cbPedido.show()
            self.ui.edPedido.hide()
            self.ui.cbPedido.setCurrentIndex(-1)

        self.ui.tablaPartidas.clear()

        self.setTipoDocumento(self.ui.cbTipoDocumento.currentText())
        self.ui.edFolio.clear()
        self.ui.edFolio.setExternalValidation(True, u"")
        self.ui.cbEntidad.setCurrentIndex(0)
        self.ui.cbOrigen.setCurrentIndex(0)
        self.ui.edNombreProducto.clear()
        self.ui.cbLinea.setCurrentIndex(-1)

        self.ui.edSubtotal.clear()
        self.ui.edDescuentoPorcentaje.clear()
        self.ui.edDescuento.clear()
        self.ui.edSubtotal2.clear()
        # self.ui.edImpuestoPorcentaje.setValue(manejador.impuestoGeneral()) DONE AT setTipoDocumento
        self.ui.edImpuesto.clear()
        self.ui.edTotal.clear()
        self.ui.laCantidadConLetra.clear()

        self.ui.cbTipoAjuste.setCurrentIndex(-1)
        self.ui.cbTipoDocumentoAjuste.setCurrentIndex(-1)
        self.ui.edFolioAjuste.clear()
        self.ui.fechaAjuste.setDate(QtCore.QDate().currentDate())
        self.ui.edMontoAjuste.clear()

        self.pago.clear()
        self.ui.frPago.hide()

        self.setStatus(statusBak)


    def codigoProductoCapturado(self):
        m = "compras.igu.Captura.codigoProductoCapturado()"
        print (1), m

        if self.ui.edCodigoProducto.completer().completionCount() == 1:
            if self.ui.edCodigoProducto.completer().popup().currentIndex().row() == -1:
                model = self.ui.edCodigoProducto.completer().completionModel()
                index = model.index(0, 0)
                self.codigoProductoSeleccionado(index)


    def codigoProductoEditado(self, texto): # print "compras.igu.Captura.codigoProductoEditado()"
        if len(texto) < 2:
            self.ui.edCodigoProducto.completer().model().clear()

        elif len(texto) == 2:
            filtros = {}
            filtros['codigo'] = unicode(texto)
            filtros['rol_id'] = self.ui.cbOrigen.itemData(self.ui.cbOrigen.currentIndex()).toInt()[0]


            acepciones = manejador.dameAcepciones(**filtros)

            self.ui.edCodigoProducto.completer().model().clear()

            if not acepciones:
                self.ui.frameCodigo.setToolTip(u"El proveedor no tiene productos que lleven estas iniciales en el código")
            else:
                self.ui.frameCodigo.setToolTip(u"")

                ## Set Model Data
                for row, acepcion in enumerate(acepciones):
                    self.ui.edCodigoProducto.completer().model().setData(row, "%s %s" % (acepcion.codigo, acepcion.nombre))
                    self.ui.edCodigoProducto.completer().model().setData(row, acepcion.id, 1001)

                self.ui.edCodigoProducto.completer().model().reset()

                # ids = [x.id for x in acepciones]
                # codigos = ["%s" % x.codigo for x in acepciones]

                # self.sender().completer().data = ids
                # self.sender().completer().model().setStringList(codigos)

            if self.ui.edCodigoProducto.text():
                self.ui.frameNombre.setEnabled(False)
                self.ui.frameNombre.setToolTip(u"Desactivado si se busca por codigo")
                self.ui.frameLinea.setEnabled(False)
                self.ui.frameLinea.setToolTip(u"Desactivado si se busca por codigo")
            else:
                self.ui.frameNombre.setEnabled(True)
                self.ui.frameNombre.setToolTip("")
                self.ui.frameLinea.setEnabled(True)
                self.ui.frameLinea.setToolTip(u"")


    def codigoProductoSeleccionado(self, completerModelIndex): # print "compras.igu.Captura.codigoProductoSeleccionado()"

        completerRow = completerModelIndex.row()

        model = self.ui.edCodigoProducto.completer().completionModel()

        acepcionOrigen = manejador.acepcionI(id=model.data(model.index(completerRow, 0), 1001).toInt()[0])

        ## Si no existe la acepción para el rol seleccionado, se utiliza la acepción para el origen seleccionado.
        if manejador.acepcionExists(producto_id=acepcionOrigen.producto.id, rol_id=self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0]):
            acepcionRol = manejador.acepcionI(producto_id=acepcionOrigen.producto.id, rol_id=self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0])
        else:
            acepcionRol = acepcionOrigen

        # ! checar el costo

        self.ui.tablaPartidas.setDatosRenglon(rowIndex=None, acepcion=acepcionRol, cantidad=dec('0.0'), precio=acepcionRol.costo)

        self.ui.edCodigoProducto.setText("")
        self.ui.edNombreProducto.setText("")
        self.ui.cbLinea.setCurrentIndex(-1)

        self.ui.frameNombre.setEnabled(True)
        self.ui.frameNombre.setToolTip("")
        self.ui.frameLinea.setEnabled(True)

        self.ui.tablaPartidas.setCurrentCell(self.ui.tablaPartidas.rowCount()-1, CANTIDAD)
        self.ui.tablaPartidas.editItem(self.ui.tablaPartidas.item(self.ui.tablaPartidas.rowCount()-1, CANTIDAD))

        self.actualizaStatus()


        # acepcion = manejador.dameAcepcion(id=self.sender().data[completerModelIndex.row()])
        # self.acepcionSeleccionada(acepcion)


    def data(self):                 # print "compras.igu.Captura.data()"
        datos = {}

        if self.modo == 'modificar':
            datos['id'] = self.id

        if self.ui.cbPedido.currentIndex() == -1 or "No hay" in self.ui.cbPedido.currentText():
            datos['pedido'] = -1
        else:
            datos['pedido'] = self.ui.cbPedido.itemData(self.ui.cbPedido.currentIndex()).toInt()[0]

        datos['tipoDocumento_id'] = self.ui.cbTipoDocumento.itemData(self.ui.cbTipoDocumento.currentIndex()).toInt()[0]
        datos['folio'] = unicode(self.ui.edFolio.text())
        datos['fecha'] = self.ui.fecha.date().toPyDate()
        # datos['orden'] = self.ui.cbPedido.currentIndex()
        datos['rol_id'] = self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0]

        datos['subtotal'] = self.ui.edSubtotal.value()
        datos['descuento'] = self.ui.edDescuento.value()
        datos['descuentoPorcentaje'] = self.ui.edDescuentoPorcentaje.value()
        datos['impuesto'] = self.ui.edImpuesto.value()
        datos['impuestoPorcentaje'] = self.ui.edImpuestoPorcentaje.value()
        datos['total'] = self.ui.edTotal.value()

        datos['condiciones'] = unicode(self.ui.cbCondiciones.currentText())
        # datos['status'] = u'pendiente'

        datos['partidas'] = self.ui.tablaPartidas.data()

        datos['pago'] = self.pago.datos

        datos['ajuste'] = {}
        if self.ui.chAjustes.isChecked():
            datos['ajuste']['tipoDocumento'] = unicode(self.ui.cbTipoDocumentoAjuste.currentText())
            datos['ajuste']['folio'] = unicode(self.ui.edFolioAjuste.text())
            datos['ajuste']['fecha'] = self.ui.fechaAjuste.dateTime().toPyDateTime()
            datos['ajuste']['monto'] = -abs(self.ui.edMontoAjuste.value())

        return datos


    def datosModificados(self):
        m = "compras.igu.Captura.datosModificados()"

        """No se modifica el proceso, sólo los documentos u operaciones"""

        datos = {}
        if self.modo==u'modificar':

            ## Operación de Entrada
            operacionCero = [x for x in self.old.operaciones if x.tipo==u'entrada']
            documentoOld = operacionCero[0].documentos[0]

            # datos['orden'] = self.ui.cbPedido.currentIndex()
            documento = {}

            if documentoOld.tipo.nombre != unicode(self.ui.cbTipoDocumento.currentText()).lower():
                documento['tipo'] = unicode(self.ui.cbTipoDocumento.currentText())

            if documentoOld.folio != unicode(self.ui.edFolio.text()):
                documento['folio'] = unicode(self.ui.edFolio.text())
            if documentoOld.fecha != self.ui.fecha.dateTime().toPyDateTime():
                documento['fecha'] = self.ui.fecha.dateTime().toPyDateTime()
            if documentoOld.rol_id != self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0]:
                documento['rol_id'] = self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0]
            if documentoOld.subtotal != self.ui.edSubtotal.value():
                documento['subtotal'] = self.ui.edSubtotal.value()
            if documentoOld.descuento != self.ui.edDescuento.value():
                documento['descuento'] = self.ui.edDescuento.value()
            if documentoOld.descuentoporcentaje != self.ui.edDescuentoPorcentaje.value():
                documento['descuentoPorcentaje'] = self.ui.edDescuentoPorcentaje.value()
            if documentoOld.impuesto != self.ui.edImpuesto.value():
                documento['impuesto'] = self.ui.edImpuesto.value()
            if documentoOld.impuestoporcentaje != self.ui.edImpuestoPorcentaje.value():
                documento['impuestoPorcentaje'] = self.ui.edImpuestoPorcentaje.value()
            if documentoOld.total != self.ui.edTotal.value():
                documento['total'] = self.ui.edTotal.value()

            # datos['condiciones'] = unicode(self.ui.cbCondiciones.currentText())
            # datos['status'] = u'pendiente'

            ## PARTIDAS
            partidasOld = manejador.damePartidas(documento_id=documentoOld.id)
            partidas = self.ui.tablaPartidas.data()
            for partidaOld in partidasOld:
                """No se contempla modificación de partidas"""
                print partidaOld
                # partida['descuento'] = datos['descuentoPorcentaje']

            if documento:
                ## Se tienen modificaciones
                documento['id'] = documentoOld.id
                datos['documento'] = documento


            ## PAGO
            operacionPagoZero = [x for x in self.old.operaciones if x.tipo==u'pago']
            if operacionPagoZero:
                if operacionPagoZero[0].documentos:
                    # documentoPago = operacionPagoZero[0].documentos[0]

                    datosModificadosPago = self.pago.datosModificados()
                    if datosModificadosPago:
                        datos['pago'] = datosModificadosPago
                else:
                    datos['pago'] = self.pago.datos


            ## AJUSTE
            if self.ui.chAjustes.isChecked():
                ajuste = {}

                # ajusteOld = [x for x in documentos if x.tipo in [u'nota de crédito']][0]

                ajusteCero = [x for x in self.old.operaciones if x.tipo==u'abono por descuento']
                if ajusteCero:
                    ajusteOld = ajusteCero[0].documentos[0]

                # datos['ajuste']['tipoDocumento'] = unicode(self.ui.cbTipoDocumentoAjuste.currentText())
                    if ajusteOld.folio != unicode(self.ui.edFolioAjuste.text()):
                        ajuste['folio'] = unicode(self.ui.edFolioAjuste.text())
                    if ajusteOld.fecha != self.ui.fechaAjuste.dateTime().toPyDateTime():
                        ajuste['fecha'] = self.ui.fechaAjuste.dateTime().toPyDateTime()
                    if ajusteOld.total != -abs(self.ui.edMontoAjuste.value()):
                        ajuste['total'] = -abs(self.ui.edMontoAjuste.value())
                else:
                    ajusteOld = None
                    ajuste['tipo'] = u'nota de crédito'
                    ajuste['rol_id'] = documentoOld.rol_id
                    ajuste['folio'] = unicode(self.ui.edFolioAjuste.text())
                    ajuste['fecha'] = self.ui.fechaAjuste.dateTime().toPyDateTime()
                    ajuste['total'] = abs(self.ui.edMontoAjuste.value())
                    ajuste['status'] = u'pendiente'

                if ajuste:
                    ## Se tienen modificaciones
                    if ajusteOld:
                        ajuste['id'] = ajusteOld.id
                    datos['ajuste'] = ajuste
            else:
                print u"Checar si esta registrado un ajuste"

            if datos:
                datos['proceso_id'] = self.old.id

        return datos


    def descuentoChanged(self):     # print "compras.igu.Captura.descuentoChanged()"
        subtotal = self.ui.edSubtotal.value()
        descuento = self.ui.edDescuento.value()

        subtotal2 = subtotal - descuento

        if self.impuestoIncluido:
            impuesto = dec("0.00")
        else:
            if self.ui.edImpuestoPorcentaje.value():
                impuesto = subtotal2 * self.ui.edImpuestoPorcentaje.value() / dec('100')
            else:
                impuesto = dec("0.00")

        total = subtotal2 + impuesto
        self.ui.edSubtotal.setValue(subtotal)
        self.ui.edDescuento.setValue(descuento)
        self.ui.edSubtotal2.setValue(subtotal2)
        self.ui.edImpuesto.setValue(impuesto)
        self.ui.edTotal.setValue(total)
        if total:
            self.ui.laCantidadConLetra.setText("Son %s" % utilities.moneyToText(self.ui.edTotal.value()))
        self.actualizaStatus()


    def estaModificado(self):
        m = "compras.igu.Captura.estaModificado()"
        print (1), m

        if self.modo == 'modificar':
            data = self.data()
            result1 = False
            modificado2 = False
            modificado3 = False
            novalido4 = False

            modificado = False

            mensajes1 = u""

            ## Entrada
            operacionCero = [x for x in self.old.operaciones if x.tipo==u'entrada']
            documento = operacionCero[0].documentos[0]

            if documento.rol_id != data['rol_id']:
                result1 = True
            if documento.subtotal != data['subtotal']:
                result1 = True
            if documento.descuento != data['descuento']:
                result1 = True
            if documento.impuesto != data['impuesto']:
                result1 = True

            print 222, documento.total, data['total']

            if documento.total != data['total']:
                result1 = True

            ## Partidas
            modificado2 = self.ui.tablaPartidas.estaModificado()

            mensajes3 = u""
            ## Pago
            if self.pago.datosModificados():
                modificado3 = True

            print 112, modificado3, self.pago.mensajes

            mensajes3 = self.pago.mensajes

            mensajes4 = u""
            operacionAjusteCero = [x for x in self.old.operaciones if x.tipo in [u'nota de crédito']]

            # ajusteCero = [x for x in documentos if x.tipo in [u'nota de crédito']]
            if operacionAjusteCero:
                print "compras.igu.Captura.estaModificado() - ajuste"
                ajuste = operacionAjusteCero[0].documentos[0]
                if ajuste.tipo != data['ajuste']['tipoDocumento']:
                    novalido4 = True
                    mensajes4 += u"Cambio en tipo de documento\n"
                if ajuste.folio != data['ajuste']['folio']:
                    novalido4 = True
                    mensajes4 += u"Cambio en folio\n"
                if ajuste.fecha != data['ajuste']['fecha']:
                    novalido4 = True
                    mensajes4 += u"Cambio en fecha\n"
                if abs(ajuste.total) != abs(data['ajuste']['monto']):
                    novalido4 = True
                    mensajes4 += u"Cambio en monto\n"
            # else:
                # self.ui.chAjustes.setChecked(False)

            print result1, modificado2, modificado3, novalido4

            if result1 or modificado2 or modificado3 or novalido4:
                self.mensajes2 = (mensajes1 + mensajes3 + mensajes4).rstrip("\n")
                return True
            else:
                return False

            print 131, self.mensajes2

            return modificado
        else:
            # print result1, result2, result3
            return True



    def esValida(self):             # print "compras.igu.Captura.esValida()"
        valida = True
        self.mensajes = ""

        if self.ui.cbTipoDocumento.currentIndex() == -1:
            valida = False
            self.mensajes += u"Debe seleccionar un tipo de Documento"

        self.revisaFolio()
        if not self.ui.edFolio.text():
            valida = False
            self.mensajes += u"Falta el folio.\n"
        elif not self.ui.edFolio.isValid:
            valida = False
            self.mensajes += u"%s\n" % self.ui.edFolio.message()

        if not self.ui.fecha.text():
            valida = False
            self.mensajes += u"Falta la fecha.\n"

        if self.ui.cbEntidad.currentIndex() <= 0:
            valida = False
            self.mensajes += u"Debe seleccionar un proveedor.\n"

        if not self.ui.cbCondiciones.currentIndex() > -1:
            self.mensajes += u"No ha seleccionado condiciones.\n"

        partidasValidas, mensajes = self.ui.tablaPartidas.esValida()
        if not partidasValidas:
            valida = False
            self.mensajes += mensajes

        if not self.ui.edSubtotal.isValid:
            valida = False
            self.mensajes += u"Subtotal fuera de rango\.n"

        if not self.ui.edDescuentoPorcentaje.isValid:
            valida = False
            self.mensajes += u"Porcentaje de descuento no válido.\n"

        if not self.ui.edDescuento.isValid:
            valida = False
            self.mensajes += u"Descuento fuera de rango.\n"

        if not self.ui.edImpuestoPorcentaje.isValid:
            valida = False
            self.mensajes += u"Porcentaje de impuesto no válido.\n"

        if not self.ui.edImpuesto.isValid:
            valida = False
            self.mensajes += u"Impuesto fuera de rango.\n"

        if not self.ui.edTotal.isValid:
            valida = False
            self.mensajes += u"Total fuera de rango.\n"

        # if self.ui.framePago2.isVisible():
            # if self.ui.cbCuenta.currentIndex() == -1:
                # valida = False
                # self.mensajes += u"Debe seleccionar una cuenta\n"

            #~ if not self.ui.edNumeroCheque.isValid:
                #~ valida = False
                #~ self.mensajes += u"%s\n" % self.ui.edNumero.message()

            # if self.ui.edMontoPago.value() == dec("0"):
                # valida = False
                # self.mensajes += u"Falta el Monto del pago\n"
            # else:
                # if not self.ui.edMontoPago.isValid:
                    # valida = False
                    # self.mensajes += u"El monto del pago no es válido\n"

        # if self.ui.frAjustes.isVisible():
            # print (667), valida

        self.mensajes = self.mensajes.rstrip("\n")

        return valida


    def fechaFocused(self):         # print "compras.igu.Captura.fechaFocused()"
        self.ui.fecha.setVisible(False)
        self.ui.fecha.setVisible(True)
        self.actualizaStatus()


    def folioEditado(self, texto):  # print "compras.igu.Captura.folioEditado()"
        self.revisaFolio()
        self.actualizaStatus()


    def guarda(self):               # print "compras.igu.Captura.guarda()"
        ## No se revisa validez de datos, para llegar aquí se tuvo que haber hecho
        if self.modo == "agregar":
            datos = self.data()
            status = manejador.agrega(datos)
            if self.ui.cbPedido.currentIndex != -1:
                self.eventRouter.emit(QtCore.SIGNAL('pedidosChangedBroadcast()'))
        else:
            datos = self.datosModificados()
            manejador.modifica(datos)

        self.hide()

        self.eventRouter.emit(QtCore.SIGNAL('productosChangedBroadcast()'))
        self.eventRouter.emit(QtCore.SIGNAL('comprasChangedBroadcast()'))

        self.cargaPedidos()

        self.emit(QtCore.SIGNAL('capturaClosed()'))


    def impuestoChanged(self):
        self.ui.edTotal.setValue(self.ui.edSubtotal.value()-self.ui.edDescuento.value()+self.ui.edImpuesto.value())
        self.totalEdited()


    @property
    def impuestoIncluido(self):
        return self.__impuestoIncluido


    def modifica(self, id):
        m = "compras.igu.Captura.modifica()"
        # print (1), m, id

        self.__modo = 'modificar'

        self.ui.titulo.setText(QtGui.QApplication.translate("Empresa Básica", "Modificación de Compra", None, QtGui.QApplication.UnicodeUTF8))


        self.clear()

        self.id = id
        proceso = manejador.procesoI(id=id)

        self.setData(proceso)

        self.ui.frameCaptura.setEnabled(True)

        self.ui.edCodigoProducto.setEnabled(False)
        self.ui.edNombreProducto.setEnabled(False)
        self.ui.cbLinea.setEnabled(False)

        self.ui.tablaPartidas.setModo(self.modo)

        self.actualizaStatus()

        # self.owner.owner.informacion = u"Para capturar partidas debe localizar el producto, por medio de su código o de su nombre"

        self.owner.setInnerStatus('hidden')

        self.show()


    @property
    def modo(self):
        return self.__modo


    def nombreProductoCapturado(self):
        m = "compras.igu.Captura.nombreProductoCapturado()"
        # print (1), m

        if self.ui.edNombreProducto.completer().completionCount() == 1:
            if self.ui.edNombreProducto.completer().popup().currentIndex().row() == -1:
                model = self.ui.edNombreProducto.completer().completionModel()
                index = model.index(0, 0)
                self.nombreProductoSeleccionado(index)


    def nombreProductoEditado(self, texto):
        m = "compras.igu.Captura.nombreProductoEditado()"
        # print (1), m

        if len(texto) < 2:
            self.ui.edNombreProducto.completer().model().clear()




        elif len(texto) == 2:
            filtros = {}


            filtros['nombre'] = unicode(texto)
            filtros['rol_id'] = self.ui.cbOrigen.itemData(self.ui.cbOrigen.currentIndex()).toInt()[0]

            # if self.ui.cbLinea.currentText():
                # filtros['linea'] = unicode(self.ui.cbLinea.currentText())

            acepciones = manejador.dameAcepciones(**filtros)
            self.ui.edNombreProducto.completer().model().clear()

            ## Set Model Data
            for row, acepcion in enumerate(acepciones):
                self.ui.edNombreProducto.completer().model().setData(row, "%s %s %s" % (acepcion.nombre, acepcion.producto.lineas[0].nombre, acepcion.codigo))
                self.ui.edNombreProducto.completer().model().setData(row, acepcion.id, 1001)

            self.ui.edNombreProducto.completer().model().reset()


    def nombreProductoSeleccionado(self, completerModelIndex=None):
        m = "compras.igu.Captura.nombreProductoSeleccionado()"
        # print (1), m

        completerRow = completerModelIndex.row()

        model = self.ui.edNombreProducto.completer().completionModel()

        acepcionOrigen = manejador.acepcionI(id=model.data(model.index(completerRow, 0), 1001).toInt()[0])

        ## Si no existe la acepción para el rol seleccionado, se utiliza la acepción para el origen seleccionado.
        if manejador.acepcionExists(producto_id=acepcionOrigen.producto.id, rol_id=self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0]):
            acepcionRol = manejador.acepcionI(producto_id=acepcionOrigen.producto.id, rol_id=self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0])
        else:
            acepcionRol = acepcionOrigen


        # ! checar el costo

        self.ui.tablaPartidas.setDatosRenglon(rowIndex=None, acepcion=acepcionRol, cantidad=dec('0.0'), precio=acepcionRol.costo)

        self.ui.edCodigoProducto.setText("")
        self.ui.edNombreProducto.setText("")
        self.ui.cbLinea.setCurrentIndex(-1)

        self.ui.tablaPartidas.setCurrentCell(self.ui.tablaPartidas.rowCount()-1, CANTIDAD)
        self.ui.tablaPartidas.editItem(self.ui.tablaPartidas.item(self.ui.tablaPartidas.rowCount()-1, CANTIDAD))

        self.actualizaStatus()


    def origenChanged(self, index):
        m = "compras.igu.Captura.origenChanged()"
        # print (1), m

        origen = manejador.rolI(id=self.ui.cbOrigen.itemData(index).toInt()[0])

        if origen.id == self.owner.app.holder.id:
            self.ui.laNombre.setText(u" &Nombre LOCAL de artículo")
        else:
            self.ui.laNombre.setText(u" &Nombre de artículo de %s %s" % (origen.entidad.nombre, origen.entidad.nombre2))

        if len(self.ui.edNombreProducto.text()) < 2:
            self.ui.edNombreProducto.completer().model().clear()
        else:
            self.nombreProductoEditado(self.ui.edNombreProducto.text()[:2])


    @property
    def owner(self):
        return self.__owner


    def paga(self):
        m = "compras.igu.Captura.paga()"
        # print (1), m

        self.pago.setImporte(self.ui.edTotal.value())
        result = self.pago.exec_()
        if result == QtGui.QDialog.Accepted:
            datos = self.pago.datos
            self.setDataPago(**datos)
            self.ui.frPago.show()
            self.actualizaStatus()
        else:
            print "hju"


    def partidaCapturada(self):
        m = "compras.igu.Captura.partidaCapturada()"

        self.ui.tablaPartidas.clearSelection()

        self.ui.edNombreProducto.setFocus()


    def pedidoSeleccionado(self, index):
        m = "compras.igu.Captura.pedidoSeleccionado()"
        print (1), m

        if index != -1:
            if not "No hay" in self.ui.cbPedido.currentText():
                pedido = manejador.damePedido(id=self.ui.cbPedido.itemData(index).toInt()[0])
                self.setDataPedido(pedido)


    def porcentajesChanged(self):
        m = "compras.igu.Captura.porcentajesChanged()"
        print (1), m

        self.totalChanged()


    @property
    def rangoPrecioActual(self):
        return self.__rangoPrecioActual


    def returnPressed(self):        # print "compras.igu.Captura.returnPressed()"
        f=g
        if self.ui.boGuardar.isEnabled():
            self.guarda()


    def revisaFolio(self):
        proveedorId = self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0]
        id = manejador.folioExiste(unicode(self.ui.edFolio.text()), proveedorId)
        if self.modo == u'agregar':
            if id:
                self.ui.edFolio.setExternalValidation(False, u"El folio ya existe para este Proveedor")
            else:
                self.ui.edFolio.setExternalValidation(True, u"")


    def rolSelected(self, index):
        if index != -1:
            rolId = self.ui.cbEntidad.itemData(index).toInt()[0]
            self.setRol(id=rolId)


    def setData(self, proceso):
        m = "compras.igu.Captura.setData()"
        # print (1), m, proceso

        self.setStatus(u"settingData")

        self.old = proceso

        ## Pedido
        solicitudCero = [x for x in proceso.operaciones if x.tipo==u'solicitud']
        if solicitudCero:
            documentoPedido = solicitudCero[0].documentos[0]
            if documentoPedido:
                self.ui.edPedido.setText("%s" % documentoPedido.folio)

        ## Entrada
        operacionEntradaCero = [x for x in proceso.operaciones if x.tipo==u'entrada']
        documento = operacionEntradaCero[0].documentos[0]

        self.ui.edFolio.setText("%s" % documento.folio)
        self.ui.fecha.setDate(QtCore.QDate().fromString(documento.fecha.strftime("%d%m%Y"), "ddMMyyyy"))

        self.setRol(documento.rol_id)

        # self.ui.cbEntidad.setCurrentIndex(self.ui.cbEntidad.findData(QtCore.QVariant(documento.rol_id)))

        self.ui.cbTipoDocumento.setCurrentIndex(self.ui.cbTipoDocumento.findData(documento.tipo_id))

        ## Partidas
        self.ui.tablaPartidas.setDatos(documento.partidas)

        self.ui.edSubtotal.setValue(documento.subtotal)
        self.ui.edDescuento.setValue(documento.descuento)
        if documento.descuentoporcentaje:
            self.ui.edDescuentoPorcentaje.setText("%.2f" % documento.descuentoporcentaje)
        else:
            self.ui.edDescuentoPorcentaje.setText("")

        self.ui.edImpuesto.setValue(documento.impuesto)

        if documento.impuestoporcentaje:
            self.ui.edImpuestoPorcentaje.setValue(documento.impuestoporcentaje)
        else:
            self.ui.edImpuestoPorcentaje.setText("")

        self.ui.edTotal.setValue(documento.total)

        self.ui.laCantidadConLetra.setText("Son %s" % utilities.moneyToText(dec(str(documento.total))))

        ## Pago
        operacionPagoZero = [x for x in proceso.operaciones if x.tipo==u'pago']
        if operacionPagoZero:
            if operacionPagoZero[0].documentos:
                documentoPago = operacionPagoZero[0].documentos[0]

                datos = {}
                datos['tipo'] = documentoPago.tipo.nombre
                datos['fecha'] = documentoPago.fecha
                datos['total'] = documentoPago.total

                if datos['tipo'] == u'efectivo':
                    datos['cambio'] = documentoPago.subtotal

                elif datos['tipo'] == u'cheque':
                    datos['cuenta'] = documentoPago.referencia
                    datos['numero'] = documentoPago.folio

                self.pago.setData(**datos)
                self.setDataPago(**datos)

                self.ui.frPago.show()
            else:
                self.ui.frPago.hide()
                self.pago.clear()

        ajusteCero = [x for x in proceso.operaciones if x.tipo==u'abono por descuento']
        if ajusteCero:
            ajuste = ajusteCero[0].documentos[0]

            # self.ui.cbTipoAjuste.setEditText(ajuste.tipo)
            self.ui.cbTipoDocumentoAjuste.setEditText(ajuste.tipo)
            self.ui.edFolioAjuste.setText(ajuste.folio)
            # print (11111), ajuste.fecha.strftime("%d%m%Y")
            # print (22222), QtCore.QDate().fromString(ajuste.fecha.strftime("%d%m%Y"), "ddMMyyyy")
            self.ui.fechaAjuste.setDate(QtCore.QDate().fromString(ajuste.fecha.strftime("%d%m%Y"), "ddMMyyyy"))
            self.ui.edMontoAjuste.setValue(ajuste.total)
            self.ui.chAjustes.setChecked(True)
        else:
            self.ui.chAjustes.setChecked(False)

        if self.modo==u"modificar":
            self.ui.laStatus.setText(proceso.status)

        self.setStatus(u'normal')


    def setDataPago(self, **datos):
        m = "compras.igu.Captura.setDataPago()"
        # print (1), m, datos

        if datos['tipo'] == u'efectivo':
            label = "en Efectivo"
            self.ui.frCuentaPago.hide()
            self.ui.frNumeroPago.hide()
            self.ui.edFechaPago.setText("%s" % datos['fecha'].strftime("%d %b %Y"))
            self.ui.edMontoPago.setText("%s" % datos['total'])
            self.ui.frCambioPago.show()
            self.ui.edCambioPago.setText("%s" % datos['cambio'])

        elif datos['tipo'] == u'cheque':
            label = "con Cheque"
            self.ui.frCuentaPago.show()
            self.ui.edCuentaPago.setText(datos['cuenta'])
            # self.ui.edCuentaPago.setText("%s %s" % (banco.entidad.alias, operacionPago.referencia))
            self.ui.frNumeroPago.show()
            self.ui.edNumeroPago.setText(datos['numero'])
            self.ui.edFechaPago.setText("%s" % datos['fecha'].strftime("%d %b %Y"))
            self.ui.edMontoPago.setText("%s" % datos['total'])
            self.ui.frCambioPago.hide()

        self.ui.laPago.setText("Pago %s" % label)


    def setDataPedido(self, documentoPedido):
        m = "compras.igu.Captura.setDataPedido()"
        # print (1), m

        self.setStatus(u'settingDataPedido')

        self.ui.cbTipoDocumento.setCurrentIndex(self.ui.cbTipoDocumento.findText(u'Factura'))

        self.ui.edFolio.setText("")
        self.ui.cbEntidad.setCurrentIndex(self.ui.cbEntidad.findData(documentoPedido.rol_id))
        self.setStatus(u'normal')

        self.ui.tablaPartidas.setDatos(documentoPedido.partidas)


    def setImpuestoIncluido(self, value):
        m = "compras.igu.Captura.setImpuestoIncluido()"
        # print (1), m

        if value:
            self.__impuestoIncluido = True
        else:
            self.__impuestoIncluido = False

        self.totalChanged(self.ui.tablaPartidas.subtotal())


    def setRol(self, rol=None, id=None):
        m = "compras.igu.Captura.setRol()"
        print (1), m, rol

        if not id is None:
            rol = manejador.rolI(id=id)
        elif rol is None:
            rol = manejador.rolI(id=self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0])

        print rol

        self.ui.tablaPartidas.setRol(rol)

        if rol.id != self.owner.app.holder.id:

            oldFocused = self.focusWidget()

            self.cargaPedidos(rol_id=rol.id)

            self.revisaFolio()

            if oldFocused:
                oldFocused.setFocus()

        self.totalChanged(self.ui.tablaPartidas.subtotal())


    def setStatus(self, valor):
        self.__status = valor
        self.ui.tablaPartidas.setStatus(valor)
        self.pago.setStatus(valor)


    def setTipoDocumento(self, tipo=None):
        m = "compras.igu.Captura.setTipoDocumento()"
        # print (1), m

        text = unicode(tipo).lower()

        if text == u'factura':
            self.ui.edImpuestoPorcentaje.setValue(manejador.impuestoGeneral())
            self.setImpuestoIncluido(False)

        elif text == u'remisión':
            self.ui.edImpuestoPorcentaje.setText('')
            self.setImpuestoIncluido(True)

        self.ui.tablaPartidas.redraw()
        self.actualizaStatus()


    def showed(self):
        if self.ui.cbEntidad.currentIndex() <= 0:
            self.owner.owner.informacion = u"Para capturar partidas debe localizar el producto, por medio de su código o de su nombre\n\n"
        else:
            self.owner.owner.informacion = u"Si no aparece el producto que desea, tal vez no existan los datos para el proveedor seleccionado."


    @property
    def status(self):
        return self.__status


    def toggleAjustes(self, state):     # print "compras.igu.Captura.toggleAjustes()"
        if state == QtCore.Qt.Checked:
            # valor = u"1"
            if not self.ui.edMontoAjuste.text():
                self.ui.edMontoAjuste.setValue(self.ui.edTotal.value())
            self.ui.frAjustes.show()
            self.actualizaStatus()
        else:
            # valor = u""
            self.ui.frAjustes.hide()
            self.actualizaStatus()


    def totalChanged(self, subtotal=None):
        m = "compras.igu.Captura.totalChanged()"
        # print (1), m

        if self.status==u'normal':
            # print (1), m

            if subtotal is None:
                subtotal = self.ui.edSubtotal.value()

            if self.ui.edDescuentoPorcentaje.value():
                descuento = subtotal * self.ui.edDescuentoPorcentaje.value() / dec("100")
            else:
                descuento = dec("0.00")

            subtotal2 = subtotal - descuento

            if self.impuestoIncluido:
                self.ui.edImpuesto.setText('')  # No aplica el despliegue de impuesto
                total = subtotal2
            else:
                if self.ui.edImpuestoPorcentaje.value():
                    impuesto = subtotal2 * self.ui.edImpuestoPorcentaje.value() / dec("100")
                else:
                    impuesto = dec("0.00")

                self.ui.edImpuesto.setValue(impuesto)
                total = subtotal2 + impuesto

            self.ui.edSubtotal.setValue(subtotal)
            self.ui.edDescuento.setValue(descuento)
            self.ui.edSubtotal2.setValue(subtotal2)
            self.ui.edTotal.setValue(total)

            if total:
                self.ui.laCantidadConLetra.setText("Son %s" % utilities.moneyToText(dec(str(self.ui.edTotal.value()))))

            self.pago.setImporte(self.ui.edTotal.value())

            self.actualizaStatus()

            # print (1), m, 'end'


    def totalEdited(self, text=None):
        m = "compras.igu.Captura.totalEdited()"
        print (1), m

        self.ui.laCantidadConLetra.setText("Son %s" % utilities.moneyToText(self.ui.edTotal.value()))
        self.actualizaStatus()



class Detalles(QtGui.QFrame):

    @property
    def owner(self):
        return self.__owner

    def __init__(self, *args, **kwds):
        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = detalles_ui.Ui_Form()
        self.ui.setupUi(self)

        self.connect(self, QtCore.SIGNAL("doubleClicked()"), self.close)
        self.connect(self.owner.eventRouter, QtCore.SIGNAL('comprasChangedBroadcast()'), self.actualiza)

        self.partidas = []
        self.id = None


    def actualiza(self, id=None):
        if id:
            self.setData(manejador.documentoI(id=id))
        elif self.id:
            self.setData(manejador.documentoI(id=self.id))


    def clear(self):
        self.ui.edPago.setText("")


    def mostrar(self, id):                  # print "compras.igu.Detalles.mostrar()"
        data = manejador.dameDocumento(id=id)
        self.setData(data)
        self.show()


    def setData(self, documento):
        m = "compras.igu.Detalles.setData()"

        self.id = documento.id
        font = QtGui.QFont()
        font.setPointSize(10)
        font.setBold(True)

        self.clear()

        self.ui.laFolio.setText("%s" % documento.folio)
        self.ui.laFecha.setText(documento.fecha.strftime("%d %b %Y"))

        proceso = [x for x in documento.operacion.procesos if x.tipo==u'compra'][0]

        pedido = [y.documentos[0] for y in x.operaciones if y.tipo==u'solicitud']

        if pedido:
            self.ui.laOrden.setText("%s" % pedido[0].folio)
            self.ui.grOrden.show()
        else:
            folioPedido = ""
            self.ui.grOrden.hide()

        # self.ui.laOrigen.setText("%s %s" % (documento.rol.entidad.nombre, documento.rol.entidad.nombre2))
        # self.ui.laOrigen.setFont(font)

        self.ui.laSubtotal.setText("%.2f" % documento.subtotal)
        self.ui.laDescuento.setText("%.2f" % documento.descuento)
        self.ui.laImpuesto.setText("%.2f" % documento.impuesto)

        self.ui.laTotal.setText("%.2f" % documento.total)
        self.ui.laTotal.setFont(font)

        font.setPointSize(8)

        font2 = QtGui.QFont()
        font2.setPointSize(9)
        font2.setBold(True)

        for row, partida in enumerate(documento.partidas):
            try:
                if row+1 == self.ui.layoutPartidas.rowCount():
                    renglon = [QtGui.QLabel(""), QtGui.QLabel(""), QtGui.QLabel(""), QtGui.QLabel(""), QtGui.QLabel(""), QtGui.QLabel("")]
                    self.partidas.append(renglon)
                    for column in range(6):
                        self.ui.layoutPartidas.addWidget(self.partidas[row][column], row+1, column)
                        if column in [0,2,5]:
                            self.partidas[row][column].setFont(font2)
                        else:
                            self.partidas[row][column].setFont(font)
                    self.partidas[row][3].setAlignment(QtCore.Qt.AlignCenter)
                    self.partidas[row][4].setAlignment(QtCore.Qt.AlignRight)
                    self.partidas[row][5].setAlignment(QtCore.Qt.AlignRight)

                for column in range(6):
                    self.partidas[row][column].show()

                acepcion = manejador.dameAcepcion(producto_id=partida.producto.id, rol_id=documento.rol_id)

                self.partidas[row][0].setText("%s " % acepcion.codigo)
                self.partidas[row][1].setText("%s " % acepcion.nombre)
                self.partidas[row][2].setText("%s " % partida.producto.lineas[0].nombre)
                self.partidas[row][3].setText("%s" % partida.cantidad)
                self.partidas[row][4].setText(" %.2f" % partida.precio)
                self.partidas[row][5].setText(" %.2f" % (partida.cantidad * partida.precio))
            except:
                print
                print "compras.igu.Detalles.setData()"
                print sys.exc_info()
                print documento
                print documento.partidas
                print partida
                print acepcion


        for row in range(len(documento.partidas), len(self.partidas)):
            for column in range(6):
                self.partidas[row][column].hide()

        ## PAGO
        pago = manejador.operacionI(tipo=u'pago', proceso_id=proceso.id)
        if pago:
            documentoPago = manejador.documentoI(operacion_id=pago.id)

            if documentoPago:
                if documentoPago.tipo.nombre == u'efectivo':
                    self.ui.edPago.setText("%s  %s   %8.2f  Cambio %8.2f" % (documentoPago.tipo.nombre.capitalize(), pago.fecha.strftime("%d-%b-%Y"), documentoPago.total, documentoPago.subtotal))
                elif documentoPago.tipo.nombre == u'cheque':
                    self.ui.edPago.setText("%s  %s   %s   %s    %8.2f" % (documentoPago.tipo.nombre.capitalize(), pago.fecha.strftime("%d-%b-%Y"), documentoPago.referencia, documentoPago.folio, documentoPago.total))
            # else:
                # self.ui.edPago.setText("En efectivo  $ %s" % pago.monto)

            self.ui.framePago.show()
        else:
            self.ui.framePago.hide()


class Pago(QtGui.QDialog):

    @property
    def capturado(self):
        return self.__capturado

    @property
    def recibido(self):
        return self.ui.edMontoRecibido.value()

    @property
    def tipo(self):
        return self.__tipo

    def __init__(self, *args, **kwds):
        m = "compras.igu.Pago.__init__()"
        print (1), m

        QtGui.QDialog.__init__(self, *args)

        self.ui = pagos_ui.Ui_Dialog()
        self.ui.setupUi(self)

        self.setWindowTitle(QtGui.QApplication.translate("DsDialog", "Taller Básico", None, QtGui.QApplication.UnicodeUTF8))
        self.setWindowIcon(QtGui.QIcon("imagenes/logo.png"))

        self.setStatus(u'init')

        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Redo.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boToggle.setIcon(icon)
        self.connect(self.ui.boToggle, QtCore.SIGNAL('clicked()'), self.toggleTipo)

        ## Fecha
        self.ui.daFecha.inicial = u""

        ## Importe
        self.ui.edImporte.setEnabled(False)
        self.ui.edImporte.setInitialValue(dec("0.00"))

        ## Tipo
        self.connect(self.ui.boToggle, QtCore.SIGNAL('clicked()'), self.toggleTipo)

        self.ui.frTipo.tipos = [x.nombre for x in manejador.formasPagoI()]
        index = self.ui.frTipo.tipos.index(u'efectivo')
        self.ui.frTipo.inicial = index
        self.toggleTipo(index)

        ## Efectivo - recibido
        # self.ui.edMontoRecibido.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edMontoRecibido.setStyleSheet('background-color:#F8F8FF;')
        self.ui.edMontoRecibido.setRange(0, 99999)
        self.ui.edMontoRecibido.setPrefijoMensaje("el pago")
        self.connect(self.ui.edMontoRecibido, QtCore.SIGNAL("textEdited(QString)"), self.actualizaCambio)
        self.ui.edMontoRecibido.setInitialValue(dec("0.00"))

        ## Efectivo - cambio
        self.ui.edCambio.setEnabled(False)
        self.ui.edCambio.setInitialValue(dec("0.00"))

        ## Cheque
        self.ui.cbCuenta.initialIndex = -1
        self.connect(self.ui.cbCuenta, QtCore.SIGNAL("currentIndexChanged(QString)"), self.actualizaStatus)

        self.connect(self.ui.edNumero, QtCore.SIGNAL("textEdited(QString)"), self.actualizaStatus)

        self.connect(self.ui.edMonto, QtCore.SIGNAL("textEdited(QString)"), self.actualizaStatus)

        ## Credito - plazo
        self.cargaCondiciones()
        self.connect(self.ui.cbPlazo, QtCore.SIGNAL('activated(int)'), self.plazoSeleccionado)

        ## Credito - pago inicial
        self.ui.frPagoInicial.hide()

        ## Aceptar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Checkmark.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boAceptar.setIcon(icon)
        self.connect(self.ui.boAceptar, QtCore.SIGNAL('clicked()'), self.aceptar)

        ## Cancelar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Cancel.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boCancelar.setIcon(icon)
        self.connect(self.ui.boCancelar, QtCore.SIGNAL('clicked()'), self.cancelar)

        self.connect(self.parent().eventRouter, QtCore.SIGNAL('cuentasChangedBroadcast()'), self.cargaCuentas)

        self.__capturado = False
        self.__status = u'normal'

        self.cargaCuentas()

        print (2), m


    def aceptar(self):
        self.__capturado = True
        self.accept()


    def actualizaCambio(self):
        m = "compras.igu.Pago.actualizaCambio()"
        cambio = self.ui.edMontoRecibido.value() - self.ui.edImporte.value()
        self.ui.edCambio.setValue(cambio)
        self.actualizaStatus()


    def actualizaStatus(self, arg=None):
        m = "compras.igu.Pago.actualizaStatus()"
        print (1), m

        if self.status == u'normal':
            if self.datosModificados():
                if self.esValido():
                    self.ui.boAceptar.setEnabled(True)
                    self.ui.boAceptar.setToolTip(u'OK')
                else:
                    self.ui.boAceptar.setEnabled(False)
                    self.ui.boAceptar.setToolTip(self.mensajes)
            else:
                self.ui.boAceptar.setEnabled(False)
                self.ui.boAceptar.setToolTip(u"No hay cambios")



    def cancelar(self):
        self.reject()


    def cargaCondiciones(self):
        registros = manejador.condicionesPago()
        self.ui.cbPlazo.clear()
        for registro in registros:
            self.ui.cbPlazo.addItem(registro.valor, QtCore.QVariant(registro.id))


    def cargaCuentas(self):
        registros = manejador.dameCuentas()
        self.ui.cbCuenta.clear()
        for registro in registros:
            self.ui.cbCuenta.addItem("%s %s" % (registro.banco.entidad.alias, registro.valor), QtCore.QVariant(registro.id))


    def clear(self):
        m = "compras.igu.Pago.clear()"
        print (1), m

        self.__capturado = False
        self.__tipo = 0

        # self.ui.daFecha.setDate(QtCore.QDate().currentDate())
        self.ui.daFecha.lineEdit().setText(u"")

        self.ui.daFecha.inicial = u""
        # self.ui.daFecha.clear()

        self.ui.edImporte.setText(u'')
        self.ui.edMontoRecibido.setInitialValue(dec('0'), actualToo=True)
        self.ui.edCambio.setInitialValue(dec('0'), actualToo=True)

        self.ui.cbCuenta.setCurrentIndex(-1)
        self.ui.edNumero.setText(u'')
        self.ui.edMonto.setText(u'')

        self.ui.cbPlazo.setCurrentIndex(-1)
        self.ui.edPagoInicial.setText(u'')


    @property
    def datos(self):
        m = "compras.igu.Pago.datos()"

        datosTemp = {}
        datos = {}

        # datos['total'] = self.ui.edImporte.value()
        datosTemp['tipo'] = self.ui.frTipo.tipos[self.ui.frTipo.index]

        if datosTemp['tipo'] == u'efectivo':
            datosTemp['fecha'] = self.ui.daFecha.date().toPyDate()
            datosTemp['total'] = self.ui.edMontoRecibido.value().quantize(dec('0.01'))
            datosTemp['cambio'] = self.ui.edCambio.value()
            datosTemp['status'] = u'cerrado'

        elif datosTemp['tipo'] == u'cheque':
            datosTemp['fecha'] = self.ui.daFecha.date().toPyDate()
            datosTemp['total'] = self.ui.edMonto.value().quantize(dec('0.01'))
            datosTemp['numero'] = self.ui.edNumero.text()
            datosTemp['cuenta'] = self.ui.cbCuenta.currentText()
            datosTemp['status'] = u'abierto'

        if datosTemp['total']:
            datos = datosTemp

        return datos


    def datosModificados(self):
        m = "compras.igu.Pago.datosModificados()"
        print (1), m

        datos = {}
        self.mensajes = u''

        if self.ui.daFecha.inicial != self.ui.daFecha.text():
            print 'fecha', self.ui.daFecha.inicial, self.ui.daFecha.text()
            datos['fecha'] = self.ui.daFecha.date().toPyDate()
            self.mensajes += u"   Modificaste la fecha\n"

        if self.ui.frTipo.inicial != self.ui.frTipo.index:
            datos['tipo'] = self.ui.frTipo.tipos[self.ui.frTipo.index]
            self.mensajes += u"   Cambiaste el tipo de pago\n"

        if self.ui.frTipo.tipos[self.ui.frTipo.index] == u'efectivo':
            if self.ui.edMontoRecibido.isModified:
                datos['total'] = self.ui.edMontoRecibido.value()
                self.mensajes += u"   Modificaste el monto recibido\n"

            # if self.ui.edCambio.isModified:
                # print "cambio", self.ui.edCambio.initialValue, self.ui.edCambio.value()
                # datos['cambio'] = self.ui.edCambio.value()
                # self.mensajes += u"   El cambio fue modificado\n"

        elif self.ui.frTipo.tipos[self.ui.frTipo.index] == u'cheque':
            if self.ui.edMonto.isModified:
                datos['total'] = self.ui.edMonto.value()
                self.mensajes += u"   Modificaste el monto del cheque\n"

            if self.ui.edNumero.isModified:
                datos['numero'] = unicode(self.ui.edNumero.text())
                self.mensajes += u"   Modificaste el numero del cheque\n"

            if self.ui.cbCuenta.initialIndex != self.ui.cbCuenta.currentIndex():
                datos['cuenta'] = unicode(self.ui.cbCuenta.currentText())
                self.mensajes += u"   Cambiaste la cuenta del cheque\n"

        if self.mensajes:
            self.mensajes = u"Pago modificado:\n" + self.mensajes

        return datos


    def estaModificado(self):
        m = "compras.igu.Pago.estaModificado()"
        # print (1), m

        modificado = False
        self.mensajes = u''

        if self.tipoInicial != self.tipos[self.tipo]:
            modificado = True
            self.mensajes += u"Cambio en tipo\n"

        if self.ui.edMontoRecibido.isModified:
            modificado = True
            self.mensajes += u"Cambio en monto recibido\n"


        if self.ui.edCambio.isModified:
            modificado = True
            self.mensajes += u"Cambio modificado\n"

        return modificado


    def esValido(self):
        valido = True
        self.mensajes = u''

        if self.ui.frTipo.tipos[self.ui.frTipo.index] == u'efectivo':
            if not self.ui.edMontoRecibido.text():
                valido = False
                self.mensajes += u"Falta el monto recibido\n"

            if self.ui.edCambio.value() < dec('0'):
                valido = False
                self.mensajes += u"El monto recibido no es válido\n"

        elif self.ui.frTipo.tipos[self.ui.frTipo.index] == u'crédito':
            if not self.ui.cbPlazo.currentText():
                valido = False
                self.mensajes += u"Falta el plazo\n"

        elif self.ui.frTipo.tipos[self.ui.frTipo.index] == u'cheque':
            if not self.ui.cbCuenta.currentText():
                valido = False
                self.mensajes += u"Falta la Cuenta\n"

            if not self.ui.edNumero.text():
                valido = False
                self.mensajes += u"Falta teclear el número\n"

            if not self.ui.edMonto.text():
                valido = False
                self.mensajes += u"Falta el monto\n"

        self.mensajes = self.mensajes.rstrip('\n')

        return valido


    def plazoSeleccionado(self):
        self.actualizaStatus()


    def setData(self, **datos):
        m = "compras.igu.Pago.setData()"
        print (1), m, datos

        if 'importe' in datos.keys():
            self.ui.edImporte.setValue(datos['importe'])

        self.ui.frTipo.inicial = self.ui.frTipo.tipos.index(datos['tipo'])
        self.toggleTipo(self.ui.frTipo.tipos.index(datos['tipo']))

        self.ui.daFecha.setDate(datos['fecha'])
        self.ui.daFecha.inicial = datos['fecha']

        if datos['tipo'] == u'efectivo':
            self.ui.edMontoRecibido.setInitialValue(dec(datos['total']), actualToo=True)
            self.ui.edCambio.setInitialValue(dec(datos['cambio']), actualToo=True)

        elif datos['tipo'] == u'cheque':
            self.ui.cbCuenta.setCurrentIndex(self.ui.cbCuenta.findText(datos['cuenta']))
            self.ui.cbCuenta.initialIndex = self.ui.cbCuenta.currentIndex()
            self.ui.edNumero.setInitialText(datos['numero'], actualToo=True)
            self.ui.edMonto.setInitialValue(datos['total'], actualToo=True)
            # self.ui.edEmisor.setText(u'%s %s' % (documento.rol.entidad.nombre, documento.rol.entidad.nombre2))

        self.actualizaStatus()


    def setImporte(self, valor):
        self.ui.edImporte.setValue(valor)
        self.actualizaCambio()
        self.ui.edMontoRecibido.setFocus()


    def setStatus(self, valor):
        self.__status = valor


    @property
    def status(self):
        return self.__status


    def toggleTipo(self, index=None):

        if index is None:
            if self.ui.frTipo.index + 1 == len(self.ui.frTipo.tipos):
                self.ui.frTipo.index = 0
            else:
                self.ui.frTipo.index += 1
        else:
            self.ui.frTipo.index = index

        if self.ui.frTipo.tipos[self.ui.frTipo.index] == u'cheque':
            self.ui.frEfectivo1.hide()
            self.ui.frCheque1.show()
            self.ui.frCredito1.hide()

            self.ui.frEfectivo.hide()
            self.ui.frBanco.show()
            self.ui.frCredito.hide()

        elif self.ui.frTipo.tipos[self.ui.frTipo.index] == u'crédito':
            self.ui.frEfectivo1.hide()
            self.ui.frCheque1.hide()
            self.ui.frCredito1.show()

            self.ui.frEfectivo.hide()
            self.ui.frBanco.hide()
            self.ui.frCredito.show()

        elif self.ui.frTipo.tipos[self.ui.frTipo.index] == u'efectivo':
            self.ui.frEfectivo1.show()
            self.ui.frCheque1.hide()
            self.ui.frCredito1.hide()

            self.ui.frEfectivo.show()
            self.ui.frBanco.hide()
            self.ui.frCredito.hide()

        self.actualizaStatus()


CODIGO, NOMBRE, LINEA, CANTIDAD, PRECIO, IMPORTE = range(6)


class TablaPartidas(QtGui.QTableWidget):

    @property
    def modo(self):
        return self.__modo

    def __init__(self, *args, **kwds):  # print "compras.igu.TablaPartidas.__init__()"
        if kwds.has_key('modo'):
            self.__modo = kwds.pop('modo')
        else:
            self.__modo = None

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QTableWidget.__init__(self, *args)

        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
        sizePolicy.setVerticalStretch(0)
        self.setSizePolicy(sizePolicy)
        self.setBaseSize(QtCore.QSize(50, 0))

        self.setWordWrap(False)
        self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)

        self.aElimina = QtGui.QAction("Eliminar", self)

        self.menu = QtGui.QMenu(self)
        self.menu.addAction(self.aElimina)

        self.edCantidad = QtGui.QLineEdit(self)
        self.edCantidad.hide()

        self.edPrecio = QtGui.QLineEdit(self)
        self.edPrecio.hide()

        self.connect(self, QtCore.SIGNAL("itemChanged(QTableWidgetItem *)"), self.itemChanged)
        self.connect(self, QtCore.SIGNAL("customContextMenuRequested(QPoint)"), self.muestraMenu)

        self.connect(self.aElimina, QtCore.SIGNAL("triggered()"), self.elimina)

        self.setStatus(u'normal')

        self.rol = self.owner.owner.app.holder

        delegate = Delegate(self)

        self.setItemDelegate(delegate)

        self.clear()


    def clear(self):
        # QtGui.QTableWidget.clearContents(self)
        for rowIndex in range(self.rowCount()):
            self.removeRow(0)
        self.partidasOld = []


    def data(self):
        """ El código y nombre pueden haber sido modificados por el capturista
        Puede que no se tenga id de acepción
        """
        partidas = []
        for row in range(self.rowCount()):
            partida = {}
            partida['producto_id'] = self.item(row, 0).data(1000).toInt()[0]
            partida['codigo'] = unicode(self.item(row, 0).text())
            partida['nombre'] = unicode(self.item(row, 1).text())

            try:
                partida['cantidad'] = dec(str(self.item(row, 3).text()))
            except:
                partida['cantidad'] = dec("0.00")

            try:
                partida['costo'] = dec(str(self.item(row, 4).text()))
            except:
                partida['costo'] = dec("0.00")

            try:
                partida['precio'] = dec(str(self.item(row, 4).text()))
            except:
                partida['precio'] = dec("0.00")

            partida['descuento'] = dec("0.00")

            partida['impuesto'] = manejador.impuestoGeneral()

            partida['status'] = u'pendiente'

            partidas.append(partida)
        return partidas


    def elimina(self):
        if self.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Eliminar partida", u"Selecciona la PARTIDA que quieres ELIMINAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Eliminar partida", u"¿Realmente quieres ELIMINAR la PARTIDA?", QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
            if result == QtGui.QMessageBox.Yes:
                self.removeRow(self.currentRow())
                self.emit(QtCore.SIGNAL("totalChanged(dec)"), self.subtotal())


    def estaModificado(self):
        m = "compras.igu.TablaPartidas.estaModificado()"
        print (1), m

        if self.modo == 'modificar':
            modificado = False
            data = self.data()
            for index, item in enumerate(self.partidasOld):
                if not(item.cantidad==data[index]['cantidad'] and item.precio==data[index]['precio']):
                    modificado = True
            return modificado


    def esValida(self):                 # print "compras.igu.TablaPartidas.esValida()"
        valida = True
        mensajes = ""
        if self.rowCount():
            partidas = self.data()
            for index, partida in enumerate(partidas):
                if partida['cantidad'] == dec("0.0"):
                    valida = False
                    mensajes += u"Falta la cantidad en la partida %s.\n" % (index + 1)
        else:
            valida = False
            mensajes += u"No hay partidas capturadas\n"
        return valida, mensajes


    def event(self, event):
        if event.type() == QtCore.QEvent.KeyPress:
            if event.key() == QtCore.Qt.Key_Return:
                if self.currentColumn() == CANTIDAD:
                    self.setCurrentCell(self.currentRow(), PRECIO)
                elif self.currentColumn() in [PRECIO, IMPORTE]:
                    self.emit(QtCore.SIGNAL('editingFinished()'))

        return QtGui.QTableWidget.event(self, event)


    def itemChanged(self, item):
        m = "compras.igu.TablaPartidas.itemChanged()"
        print (1), m, self.status

        if self.status == 'normal':
            if item.column() == CANTIDAD:
                self.redraw(item)

            if item.column() == PRECIO:
                print 88888877
                if self.owner.impuestoIncluido:
                    self.item(item.row(), PRECIO).setData(1000, QtCore.QVariant("%s" % dec(str(self.item(item.row(), 4).text()))))
                    self.item(item.row(), PRECIO).setData(1001, QtCore.QVariant("%s" % (dec(str(self.item(item.row(), 4).text()))/self.owner.impuestoGeneralFactor)))
                else:
                    self.item(item.row(), PRECIO).setData(1000, QtCore.QVariant("%s" % (dec(str(self.item(item.row(), 4).text()))*self.owner.impuestoGeneralFactor)))
                    self.item(item.row(), PRECIO).setData(1001, QtCore.QVariant("%s" % (dec(str(self.item(item.row(), 4).text())))))

                self.redraw(item)


    def muestraMenu(self, pos):         # print "compras.igu.TablaPartidas.muestraMenu()"
        pos = self.mapToGlobal(pos)
        self.menu.popup(pos)


    @property
    def owner(self):
        return self.__owner


    def redraw(self, item=None):
        m = "compras.igu.TablaPartidas.redraw()"
        print (1), m, self.status, item

        def redrawRow(item):
            oldStatus = self.status
            self.setStatus(u'redrawing')

            try:
                ## Valida existencia de acepcion
                if self.item(item.row(), CODIGO).data(1001).toString() == u"No existe":
                    print 10001
                    for colIndex in [CODIGO, NOMBRE]:
                        self.item(item.row(), colIndex).setBackgroundColor(QtGui.QColor("#FFFF80"))
                        self.item(item.row(), colIndex).setToolTip(u"No existe registro de producto para este Proveedor")
                else:
                    print 10002
                    for colIndex in [CODIGO, NOMBRE]:
                        self.item(item.row(), colIndex).setBackgroundColor(QtGui.QColor("#FFFFFF"))
                        self.item(item.row(), colIndex).setToolTip(u"")

                ## Validar cantidad
                print self.item(item.row(), CANTIDAD).text()
                if dec(str(self.item(item.row(), CANTIDAD).text())) == dec('0'):
                    # self.item(item.row(), CANTIDAD).setData(1001, QtCore.QVariant("overflow"))
                    self.item(item.row(), CANTIDAD).setBackgroundColor(QtGui.QColor("#FF8080"))
                else:
                    # self.item(item.row(), CANTIDAD).setData(1001, QtCore.QVariant(""))
                    self.item(item.row(), CANTIDAD).setBackgroundColor(QtGui.QColor("#FFFFFF"))

                ## Valida Precios
                if dec(str(self.item(item.row(), PRECIO).data(1000).toString())) != dec(str(self.item(item.row(), PRECIO).data(2000).toString())):
                    print 10004
                    self.item(item.row(), PRECIO).setBackgroundColor(QtGui.QColor("#FFFF80"))
                    if dec(str(self.item(item.row(), PRECIO).data(2000).toString())) == dec("-1"):
                        self.item(item.row(), PRECIO).setToolTip(u"No existe registro de producto para este Proveedor")
                    else:
                        self.item(item.row(), PRECIO).setToolTip(u"Este precio no es el registrado para este proveedor")
                else:
                    print 10005
                    self.item(item.row(), PRECIO).setBackgroundColor(QtGui.QColor("#FFFFFF"))
                    self.item(item.row(), PRECIO).setToolTip(u"")

                ## Recalcular
                if self.owner.impuestoIncluido:
                    print 10006
                    self.item(item.row(), PRECIO).setText("%s" % dec(str(self.item(item.row(), PRECIO).data(1000+self.owner.rangoPrecioActual*10).toString())).quantize(dec('0.01')))

                else:
                    print 10007
                    self.item(item.row(), PRECIO).setText("%s" % dec(str(self.item(item.row(), PRECIO).data(1001+self.owner.rangoPrecioActual*10).toString())).quantize(dec('0.01')))

                importe = (dec(str(self.item(item.row(), CANTIDAD).text())) * dec(str(self.item(item.row(), PRECIO).text()))).quantize(dec('0.01'))

                self.item(item.row(), IMPORTE).setText("%s" % importe)

            except:
                pass

            self.setStatus(oldStatus)

        if self.status == u'normal':
            # print (1), m
            if item is None:
                for rowIndex in range(self.rowCount()):
                    redrawRow(self.item(rowIndex, 0))
            else:
                redrawRow(item)

            self.emit(QtCore.SIGNAL("totalChanged(dec)"), self.subtotal())
            # print (1), m, 'end'


    def setDatos(self, partidas):
        m = "compras.igu.TablaPartidas.setDatos()"
        # print (1), m

        oldStatus = self.status
        self.setStatus(u'setting data')

        self.partidasOld = partidas
        for index, partida in enumerate(partidas):
            acepcion = manejador.acepcionI(producto_id=partida.producto_id, rol_id=self.rol.id)
            self.setDatosRenglon(index, acepcion, partida.cantidad, partida.precio)

        self.setStatus(oldStatus)
        self.redraw()


    def setDatosRenglon(self, rowIndex, acepcion, cantidad, precio):
        m = "compras.igu.TablaPartidas.setDatosRenglon()"
        # print (1), m

        if rowIndex is None:
            rowIndex = self.rowCount()
            self.insertRow(self.rowCount())
        else:
            if self.rowCount() <= rowIndex:
                self.insertRow(self.rowCount())


        oldStatus = self.status
        self.setStatus(u'settingDatosRenglon')

        ## CÓDIGO
        item = QtGui.QTableWidgetItem("%s" % acepcion.codigo)   # may be int not unicode
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        item.setData(1000, QtCore.QVariant(acepcion.producto_id))
        if acepcion.rol_id==self.rol.id:
            item.setData(1001, QtCore.QVariant(u""))
        else:
            item.setData(1001, QtCore.QVariant(u"No existe"))
        self.setItem(rowIndex, CODIGO, item)

        ## NOMBRE
        item = QtGui.QTableWidgetItem(acepcion.nombre)
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        self.setItem(rowIndex, NOMBRE, item)

        ## LINEA
        item = QtGui.QTableWidgetItem(acepcion.producto.lineas[0].nombre)
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        self.setItem(rowIndex, LINEA, item)

        ## CANTIDAD
        item = QtGui.QTableWidgetItem("%s" % cantidad)
        item.setTextAlignment(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter)
        item.setData(1000, QtCore.QVariant("%s" % acepcion.producto.maximo))
        self.setItem(rowIndex, CANTIDAD, item)

        ## PRECIO
        """ 1000 Precio Iva incluido
            1001 Precio Iva desglosado """
        item = QtGui.QTableWidgetItem("")
        item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)

        if self.owner.impuestoIncluido:
            item.setText("%s" % (precio*self.owner.impuestoGeneralFactor))
        else:
            item.setText("%s" % precio)

        item.setData(1000, QtCore.QVariant("%s" % (dec(precio)*self.owner.impuestoGeneralFactor)))  # Impuesto incluído
        item.setData(1001, QtCore.QVariant("%s" % (dec(precio))))
        item.setData(2000, QtCore.QVariant("%s" % (dec(precio)*self.owner.impuestoGeneralFactor)))
        item.setData(2001, QtCore.QVariant("%s" % (dec(precio))))

        self.setItem(rowIndex, PRECIO, item)

        ## IMPORTE
        item = QtGui.QTableWidgetItem("%s" % (cantidad * precio))
        item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignCenter)
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        self.setItem(rowIndex, IMPORTE, item)

        self.setStatus(oldStatus)

        self.redraw(self.item(rowIndex, 0))

        self.resizeColumnToContents(CODIGO)
        self.resizeColumnToContents(LINEA)
        self.resizeColumnToContents(CANTIDAD)

        self.owner.owner.owner.informacion = u"Presiona F2 para modificar datos en la celda"


    def setModo(self, modo):            # print "compras.igu.TablaPartidas.setModo()"
        self.__modo = modo

        if modo == 'agregar':
            self.menu = QtGui.QMenu(self)
            self.menu.addAction(self.aElimina)
        elif modo == 'modificar':
            self.menu = QtGui.QMenu(self)


    def setRol(self, rol=None, id=None):
        """ Recibe instancia de Rol o id de Rol
            Actualiza codigo y nombre de cada renglón de la tabla de partidas
            Según si existe con la acepción del rol recibido, con la acepción del rol de origen seleccionado o con la acepción local.
            En caso de registrarse los datos y no existir la acepción del rol recibido, se crea con los datos de la acepción capturada.
        """
        m = "compras.igu.TablaPartidas.setRol()"
        # print (1), m, id, rol

        if rol:
            self.rol = rol
        elif id:
            self.rol = manejador.rolI(id=id)

        if self.rol.id == self.owner.owner.app.holder.id:
            self.horizontalHeaderItem(1).setText(u"Nombre LOCAL de artículo")
        else:
            self.horizontalHeaderItem(1).setText(u"Nombre de artículo para %s %s" % (self.rol.entidad.nombre, self.rol.entidad.nombre2))

        for rowIndex in range(self.rowCount()):

            if manejador.acepcionExists(producto_id=self.item(rowIndex, CODIGO).data(1000).toInt()[0], rol_id=self.rol.id):
                acepcion = manejador.acepcionI(producto_id=self.item(rowIndex, CODIGO).data(1000).toInt()[0], rol_id=self.rol.id)
                self.item(rowIndex, CODIGO).setData(1001, QtCore.QVariant(u""))

                self.item(rowIndex, PRECIO).setData(2000, QtCore.QVariant("%s" % (acepcion.costo*self.owner.impuestoGeneralFactor)))
                self.item(rowIndex, PRECIO).setData(2001, QtCore.QVariant("%s" % acepcion.costo))

            else:
                if manejador.acepcionExists(producto_id=self.item(rowIndex, CODIGO).data(1000).toInt()[0], rol_id=self.owner.ui.cbOrigen.itemData(self.owner.ui.cbOrigen.currentIndex()).toInt()[0]):
                    ## Si no existe la acepción para el rol seleccionado, se busca la acepción para el rol de origen seleccionado
                    acepcion = manejador.acepcionI(producto_id=self.item(rowIndex, CODIGO).data(1000).toInt()[0], rol_id=self.owner.ui.cbOrigen.itemData(self.owner.ui.cbOrigen.currentIndex()).toInt()[0])
                else:
                    ## Si no existe la acepción para el rol de origen, se busca la acepción local
                    acepcion = manejador.acepcionI(producto_id=self.item(rowIndex, CODIGO).data(1000).toInt()[0], rol_id=self.owner.owner.app.holder.id)

                self.item(rowIndex, CODIGO).setData(1001, QtCore.QVariant(u"No existe"))

                self.item(rowIndex, PRECIO).setData(2000, QtCore.QVariant("-1"))
                self.item(rowIndex, PRECIO).setData(2001, QtCore.QVariant("-1"))

            self.item(rowIndex, CODIGO).setText("%s" % acepcion.codigo)
            self.item(rowIndex, NOMBRE).setText("%s" % acepcion.nombre)

        self.redraw()


    def setStatus(self, valor):
        self.__status = valor


    @property
    def status(self):
        return self.__status


    def subtotal(self):
        m = "compras.igu.TablaPartidas.subtotal()"
        # print (1), m

        subtotal = dec("0.00")
        for row in range(self.rowCount()):
            importe = dec(str(self.item(row, IMPORTE).text()))
            subtotal += importe
        return subtotal



class Delegate(QtGui.QItemDelegate):

    def createEditor(self, parent, option, index):
        if index.column() in [3, 4]:
            editor = cdWidgets.cdLineEdit.CDLineEdit(parent)
            editor.hasStatusLabel(False)
            self.connect(editor, QtCore.SIGNAL('returnPressed()'), self.commitAndCloseEditor)
            return editor
        else:
            return QtGui.QItemDelegate.createEditor(self, parent, option, index)

    def commitAndCloseEditor(self):
        editor = self.sender()
        if isinstance(editor, (QtGui.QTextEdit, QtGui.QLineEdit)):
            self.emit(QtCore.SIGNAL('commitData(QWidget*)'), editor)
            self.emit(QtCore.SIGNAL('closeEditor(QWidget*)'), editor)
            self.emit(QtCore.SIGNAL('editingFinished(QWidget*)'), editor)



class Splitter(QtGui.QSplitter):

    def __init__(self, *args):
        self.orientation = args[0]
        QtGui.QSplitter.__init__(self, *args)

    def createHandle(self):
        return Handle(self.orientation, self)



class Handle(QtGui.QSplitterHandle):

    def __init__(self, *args):
        QtGui.QSplitterHandle.__init__(self, *args)

    def mouseDoubleClickEvent(self, event): # print "Handle.mousePressEvent()"
        self.emit(QtCore.SIGNAL("handlePressed"))



class Model(QtCore.QAbstractListModel):

    def __init__(self, *args):
        QtCore.QAbstractListModel.__init__(self, *args)
        self.__data = []


    def clear(self):
        # self.beginRemoveRows(QtCore.QModelIndex(), 0, self.rowCount())
        self.__data = []
        self.reset()
        # self.endRemoveRows()


    def data(self, index, role=QtCore.Qt.DisplayRole):
        if role in [QtCore.Qt.DisplayRole, QtCore.Qt.EditRole]:
            return self.__data[index.row()][index.column()]
        elif role == QtCore.Qt.TextAlignmentRole:
            # if index.column() == CANTIDAD:
                # return QtCore.QVariant(int(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter))
            # if index.column() in [PRECIO, IMPORTE]:
                # return QtCore.QVariant(int(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter))
            return QtCore.QVariant(int(QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter))
        elif role == 1001:
            return self.__data[index.row()][1]
        else:
            return QtCore.QVariant()


    def insertRow(self, row, parent=QtCore.QModelIndex()):
        self.__data.insert(row, [QtCore.QVariant(u""), QtCore.QVariant(u"")])
        return True


    def rowCount(self, parent=QtCore.QModelIndex()):
        return len(self.__data)


    def setData(self, row, valor, role=QtCore.Qt.DisplayRole):
        """ No se usa la porquería de modelIndex """
        if row >= len(self.__data):
            self.__data.append([None, None])

        if role in [QtCore.Qt.DisplayRole, QtCore.Qt.EditRole]:
            self.__data[row][0] = QtCore.QVariant(valor)
        elif role == 1001:
            self.__data[row][1] = QtCore.QVariant(valor)
        else:
            print "puaj"
        return True




# print (0), "  compras.igu           end"


## Se tiene instalada la capacidad de modificacion de acepción, pero
## se deshabilitó por fines de simplicidad.
